Pythonmonkey

- fixed a bug where users without Rust and cargo installed could not install pythonmonkey from a source distribution

- added a new build type:
- **Sanitize**: same as **Debug**, except with [AddressSanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer) enabled
- added a new tool inspired by [wtfnode](https://www.npmjs.com/package/wtfnode) called WTFPythonMonkey to track down any hanging `setTimeout`/`setInterval` timers that are still ref'd when you hit ctrl-C.
- When using `pmjs`, to enable it you can simply pass the `--wtf` flag, like so:
bash
pmjs --wtf <filename>.js

- When using pythonmonkey from python, it can be enabled by using a [context manager (`with`-statement)](https://github.com/Distributive-Network/PythonMonkey/blob/c80f2ec4e7ca1c83c70a31556bbbc165529d41f3/python/pythonmonkey/lib/wtfpm.py#L16-L28) around the entry point of the event loop, like so:
py
import asyncio
import pythonmonkey as pm
from pythonmonkey.lib.wtfpm import WTF

async def pythonmonkey_main():
pm.eval("setInterval(() => console.log(new Date), 500)")
await pm.wait()

with WTF():
asyncio.run(pythonmonkey_main())

- implemented JS-like function calling for python functions in JS. Similar to JS functions, you can now call python functions with too few or too many arguments without throwing an error.
- When too many arguments are supplied, those beyond the function's parameter count are ignored, e.g.:
py
def f(a, b):
return [a, b]
assert [1, 2] == pm.eval("(f) => f(1, 2, 3)")(f)

- When too few arguments are supplied, those beyond the number of supplied arguments are passed as `None` to match JS's behaviour of passing `undefined`, e.g.:
py
def f(a, b):
return [a, b]
assert [1, None] == pm.eval("(f) => f(1)")(f)

- This also works for functions with default arguments, or varargs, e.g.:
py
def f(a, b, c=42, d=43, *args):
return [a, b, c, d, *args]
assert [1, 2, 3, 4, 5] == pm.eval("(f) => f(1, 2, 3, 4, 5)")(f)
assert [1, 2, 3, 4 ] == pm.eval("(f) => f(1, 2, 3, 4)" )(f)
assert [1, 2, 3, 43 ] == pm.eval("(f) => f(1, 2, 3)" )(f)
assert [1, 2, 42, 43 ] == pm.eval("(f) => f(1, 2)" )(f)
assert [1, None, 42, 43 ] == pm.eval("(f) => f(1)" )(f)
assert [None, None, 42, 43 ] == pm.eval("(f) => f()" )(f)

- implemented the [copy protocol](https://docs.python.org/3/library/copy.html) (both `copy.copy` and `copy.deepcopy`) for JSStringProxies
- using the aforementioned WTFPythonMonkey, we've fixed several bugs related to timers, including:
- the `Future object is not initialized` error and following segfault
- heap-use-after-free in `timerJobWrapper`
- hitting ctrl-C in `pmjs` printing out the entire Python `KeyboardInterrupt` traceback
- intervals from `setInterval` were not being unref'd correctly
- fixed a bug where uncaught JS Promise rejections would result in a `Future exception was never retrieved` Python error, rather than the actual JS error
- added support for `HTTP-Keep-Alive` in our implementation of `XMLHttpRequest`
- fixed a memory leak related to cross-language strings
- fixed a bug where attempting to install Pythonmonkey from source failed on Ubuntu 24.04
- PythonMonkey now uses the [bleeding edge version of SpiderMonkey](https://hg.mozilla.org/mozilla-central/) on this and all future releases
- we now build and distribute binaries for python 3.8 on amd64 Mac OS

- significant performance improvements, particularly in memory usage
- improved build system and build time, including making building the docs optional, and the following build types:
- **Release**: stripped symbols, maximum optimizations (default, what gets published on pip)
- **DRelease**: same as **Release**, except symbols are not stripped
- **Debug**: minimal optimizations
- **Profile**: same as **Debug**, except profiling is enabled
- fixed a bug where users with particularly old versions of PythonMonkey were unable to update to the latest release using pip unless they completely uninstalled PythonMonkey first

- fixed a bug where `pmjs -e` / `pmjs -p` was not able to call functions that require the event loop
- implemented [setInterval](https://developer.mozilla.org/en-US/docs/Web/API/setInterval) and [clearInterval](https://developer.mozilla.org/en-US/docs/Web/API/clearInterval)
- implemented further cross-language support for iterators (more widespread use of iterators, such as the for-of loop for arrays, was already working in previous versions)

using a JS iterator in python:
py
import pythonmonkey as pm

myit = pm.eval('(function* () { yield 1; yield 2; })')()

- fixed a bug where methods called on proxied JS objects would use `globalThis` for the value of `this`
- implemented proxying of arbitrary python objects in JavaScript, like so:
py
import pythonmonkey as pm

class Counter:
def __init__(self):
self.count = 0
def increment(self):
self.count = self.count + 1

counter = Counter()

pm.eval("""
(pyObject) => {
console.log(pyObject.count); // 0
pyObject.increment();
console.log(pyObject.count); // 1
}
""")(counter)

- implemented a new type called JSMethodProxy, which can be used to implement methods on python objects in JavaScript, like so:
py
import pythonmonkey as pm

jsFunc = pm.eval("(function() { this.count++; })")

class Counter:
def __init__(self):
self.count = 0
self.increment = pm.JSMethodProxy(jsFunc, self)

counter = Counter()
print(counter.count) 0
counter.increment()
print(counter.count) 1

- various garbage collection optimizations
- various memory leak fixes
- implemented complete cross-language stack traces
- `pm.eval` can now accept a file object as its first argument (such as an object returned by the `open()` python built-in), which is expected to be a javascript file
- when calling `pm.require` (or other requires created by `pm.createRequire`), .py CommonJS modules now have precedence over .js modules when there is a namespace collision
- `setTimeout` now returns a Node.js-style `Timeout` class for the timeout id, with `.ref()` and `.unref()` methods
- implemented `XMLHttpRequest.withCredentials`
- implemented `"json"` support for `XMLHttpRequest.responseType`
- implemented remaining standard `console` methods

Our JS Proxies now implement all Array and Object methods on Python Lists and Dicts, and our Python List and Dict subtypes implements operators and methods on JS Arrays and Objects.

One can now do
py
items = [1, 2, 3, 4, 5]
result = [None]
pm.eval("(result, arr) => {result[0] = arr.some((element) => element % 2 === 0)}")(result, items)
-> result[0] == True

and going the other way
py
a = pm.eval("([1,2,3,4,5,6])")
b = a[1:5]
-> b == [2,3,4,5]

We also have all the iterators returned by such methods as values() now working without making copies of the object being iterated upon