12 Commits

Author	SHA1	Message	Date
Damien George	a319ddefa6	webassembly: Improve identity and fix bug with lost JsProxy refs. ... Commit ffa98cb014 improved equality for `JsProxy` objects so that, eg, `js.Object == js.Object` is true. As mentioned in #17758, a further optimisation is to make identity work in that case, eg `js.Object is js.Object` should be true (on the Python side). This commit implements that, by keeping track of all `JsProxy` Python objects and reusing them where possible: where the underlying JS ref is equal, ie they point to the same JS object. That reduces memory churn and gives better identity behaviour of JS objects proxied over to Python. As part of this, a bug is fixed where JS objects can be freed while there's still a `JsProxy` referring to that JS object. A test is added for that exact scenario, and the test now passes. Signed-off-by: Damien George <damien@micropython.org>	2025-09-26 14:07:07 +10:00
Damien George	ffa98cb014	webassembly/proxy_js: Reuse JsProxy ref if object matches. ... This reduces memory use by reusing objects, and improves identity/equality relationships of JavaScript objects on the Python side. In 77bd8fe5b8 PyProxy's were reused when the same Python object was proxied across to JavaScript. This commit does the same thing but for JsProxy's going from JS to Python. If an existing JsProxy reference exists for the JS object about to be proxied across, then it's reused. This helps reduce the number of alive objects (memory use), and, more importantly, improves equality relationships of JavaScript objects on the Python side. Eg we now get, on the Python side: import js print(js.Object == js.Object) that prints True. Previously it was False. Note that this change does not make identity work with `is`, for example `js.Object is js.Object` is actually False. With more work that could be made True but for now we leave that as-is. The behaviour with this commit matches Pyodide semantics. Signed-off-by: Damien George <damien@micropython.org>	2025-07-31 11:40:50 +10:00
Damien George	77bd8fe5b8	webassembly: Reuse PyProxy objects when they are the same Python object. ... This commit makes it so that PyProxy objects are reused (on the JavaScript side) when they correspond to an existing Python object that is the same object. For example, proxying the same Python function to JavaScript, the same PyProxy instance is now used. This means that if `foo` is a Python function then accessing it on the JavaScript side such as `api.globals().get("foo")` has the property that: api.globals().get("foo") === api.globals().get("foo") Prior to this commit the above was not true because new PyProxy instances were created each time `foo` was accessed. Signed-off-by: Damien George <damien@micropython.org>	2024-07-19 11:55:24 +10:00
Damien George	57a9ffa632	webassembly: Register PyProxy objects for JS-side finalisation. ... And clear the corresponding `proxy_c_ref[c_ref]` entry when the finaliser runs. This then allows the C side to (eventually) garbage collect the corresponding Python object. Signed-off-by: Damien George <damien@micropython.org>	2024-05-22 17:37:37 +10:00
Damien George	5c7a414574	webassembly: Add C-level finaliser to JsProxy object. ... And clear the corresponding `proxy_js_ref[js_ref]` entry when the finaliser runs. This then allows the JavaScript side to (eventually) free the corresponding JavaScript object. Signed-off-by: Damien George <damien@micropython.org>	2024-05-22 17:06:18 +10:00
Damien George	aa2e3880c1	webassembly/proxy_js: Create a special "undefined" type for Python. ... This adds a new undefined singleton to Python, that corresponds directly to JavaScript `undefined`. It's accessible via `js.undefined`. Signed-off-by: Damien George <damien@micropython.org>	2024-05-16 12:49:10 +10:00
Damien George	0148bbb495	webassembly/proxy_js: Revert back to converting Py None to JS null. ... This reverts part of commit fa23e4b093, to make it so that Python `None` converts to JavaScript `null` (and JavaScript `null` already converts to Python `None`). That's consistent with how the `json` module converts these values back and forth. Signed-off-by: Damien George <damien@micropython.org>	2024-05-16 12:44:43 +10:00
Damien George	fa23e4b093	webassembly/proxy_js: Convert JS undefined and JS null to Py None. ... And change Py None conversion so it converts to JS undefined. The semantics for conversion of these objects are then: - Python None -> JavaScript undefined - JavaScript undefined -> Python None - JavaScript null -> Python None This follows Pyodide: https://pyodide.org/en/stable/usage/type-conversions.html Signed-off-by: Damien George <damien@micropython.org>	2024-05-13 11:53:10 +10:00
Damien George	5114f2c1ea	webassembly/proxy_js: Allow a Python proxy of a function to be undone. ... This optimises the case where a Python function is, for example, stored to a JavaScript attribute and then later retrieved from Python. The Python function no longer needs to be a proxy with double proxying needed for the call from Python -> JavaScript -> Python. Signed-off-by: Damien George <damien@micropython.org>	2024-03-30 13:13:51 +11:00
Damien George	7c62fbe3f2	webassembly/proxy_js: Promote Python thenable to a Promise. ... Signed-off-by: Damien George <damien@micropython.org>	2024-03-30 13:13:51 +11:00
Damien George	9b090603a0	webassembly: Implement runPythonAsync() for top-level async code. ... With this commit, `interpreter.runPythonAsync(code)` can now be used to run Python code that uses `await` at the top level. That will yield up to JavaScript and produce a thenable, which the JavaScript runtime can then resume. Also implemented is the ability for Python code to await on JavaScript promises/thenables. For example, outer JavaScript code can await on `runPythonAsync(code)` which then runs Python code that does `await js.fetch(url)`. The entire chain of calls will be suspended until the fetch completes. Signed-off-by: Damien George <damien@micropython.org>	2024-03-22 13:37:47 +11:00
Damien George	39bd0b8a0a	webassembly: Add JavaScript proxying, and js and jsffi modules. ... This commit improves the webassembly port by adding: - Proxying of Python objects to JavaScript with a PyProxy type that lives on the JavaScript side. PyProxy implements JavaScript Proxy traps such as has, get, set and ownKeys, to make Python objects have functionality on the JavaScript side. - Proxying of JavaScript objects to Python with a JsProxy type that lives on the Python side. JsProxy passes through calls, attributes, subscription and iteration from Python to JavaScript. - A top-level API on the JavaScript side to construct a MicroPython interpreter instance via `loadMicroPython()`. That function returns an object that can be used to execute Python code, access the Python globals dict, access the Emscripten filesystem, and other things. This API is based on the API provided by Pyodide (https://pyodide.org/). As part of this, the top-level file is changed from `micropython.js` to `micropython.mjs`. - A Python `js` module which can be used to access all JavaScript-side symbols, for example the DOM when run within a browser. - A Python `jsffi` module with various helper functions like `create_proxy()` and `to_js()`. - A dedenting lexer which automatically dedents Python source code if every non-empty line in that source starts with a common whitespace prefix. This is very helpful when Python source code is indented within a string within HTML or JavaScript for formatting reasons. Signed-off-by: Damien George <damien@micropython.org>	2024-03-22 13:37:47 +11:00