pyodide.ffi#
Exceptions:
An error thrown when conversion between JavaScript and Python fails. |
|
|
A JavaScript Error. |
Classes:
|
A JsProxy of an |
A JavaScript |
|
A JavaScript async iterable object |
|
A JsProxy of a JavaScript async iterator. |
|
|
A JsProxy of an array buffer or array buffer view |
A JavaScript callable |
|
A double proxy created with |
|
A |
|
A JavaScript generator |
|
A JavaScript iterable object |
|
A JsProxy of a JavaScript iterator. |
|
|
A JavaScript Map |
A JavaScript mutable map |
|
A JavaScript handle for a Python function which can be called at most once. |
|
A |
|
|
A proxy to make a JavaScript object behave like a Python object |
Functions:
|
Wrap a Python Callable in a JavaScript function that can be called once. |
|
|
|
Destroy all PyProxies in a JavaScript array. |
|
Registers |
|
Block until an awaitable is resolved. |
|
Convert the object to JavaScript. |
|
Unregisters a JavaScript module with given name that has been previously registered with |
- exception pyodide.ffi.ConversionError#
Bases:
Exception
An error thrown when conversion between JavaScript and Python fails.
- class pyodide.ffi.JsArray#
Bases:
JsIterable
[T
],Generic
[T
],MutableSequence
[T
]A JsProxy of an
Array
,NodeList
, orTypedArray
- extend(other, /)#
Extend array by appending elements from the iterable.
- index(value, start=0, stop=9223372036854775807)#
Return first
index
at whichvalue
appears in theArray
.Raises
ValueError
if the value is not present.
- insert(index, value)#
Insert an item at a given position.
The first argument is the index of the element before which to insert, so
a.insert(0, x)
inserts at the front of the list, anda.insert(len(a), x)
is equivalent toa.append(x)
.
- pop(index=-1)#
Remove and return the
item
atindex
(default last).Raises
IndexError
if list is empty or index is out of range.- Parameters:
index (
int
)- Return type:
T
- remove(value)#
Remove the first item from the list whose value is equal to
x
.It raises a
ValueError
if there is no such item.- Parameters:
value (
T
)- Return type:
- to_py(*, depth=-1, default_converter=None)#
Convert the
JsProxy
to a native Python object as best as possible.See JavaScript to Python for more information.
- Parameters:
depth (
int
) – Limit the depth of the conversion. If a shallow conversion is desired, setdepth
to 1.default_converter (
Callable
[[JsProxy
,Callable
[[JsProxy
],Any
],Callable
[[JsProxy
,Any
],None
]],Any
] |None
) – If present, this will be invoked whenever Pyodide does not have some built in conversion for the object. Ifdefault_converter
raises an error, the error will be allowed to propagate. Otherwise, the object returned will be used as the conversion.default_converter
takes three arguments. The first argument is the value to be converted.
- Return type:
Examples
Here are a couple examples of converter functions. In addition to the normal conversions, convert
Date
todatetime
:from datetime import datetime def default_converter(value, _ignored1, _ignored2): if value.constructor.name == "Date": return datetime.fromtimestamp(d.valueOf()/1000) return value
Don’t create any JsProxies, require a complete conversion or raise an error:
def default_converter(_value, _ignored1, _ignored2): raise Exception("Failed to completely convert object")
The second and third arguments are only needed for converting containers. The second argument is a conversion function which is used to convert the elements of the container with the same settings. The third argument is a “cache” function which is needed to handle self referential containers. Consider the following example. Suppose we have a Javascript
Pair
class:class Pair { constructor(first, second){ this.first = first; this.second = second; } }
We can use the following
default_converter
to convertPair
tolist
:def default_converter(value, convert, cache): if value.constructor.name != "Pair": return value result = [] cache(value, result); result.append(convert(value.first)) result.append(convert(value.second)) return result
Note that we have to cache the conversion of
value
before convertingvalue.first
andvalue.second
. To see why, consider a self referential pair:let p = new Pair(0, 0); p.first = p;
Without
cache(value, result);
, convertingp
would lead to an infinite recurse. With it, we can successfully convertp
to a list such thatl[0] is l
.
- class pyodide.ffi.JsAsyncGenerator#
Bases:
JsAsyncIterable
[T_co
],Generic
[T_co
,T_contra
,V_co
]A JavaScript
AsyncGenerator
A JavaScript object is treated as an async generator if it’s
Symbol.toStringTag
is"AsyncGenerator"
. Most likely this will be because it is a true async generator produced by the JavaScript runtime, but it may be a custom object trying hard to pretend to be an async generator. It should havenext()
,return()
, andthrow()
methods.- aclose()#
Raises a
GeneratorExit
at the point where the generator function was paused.If the generator function then exits gracefully, is already closed, or raises
GeneratorExit
(by not catching the exception),aclose()
returns to its caller. If the generator yields a value, aRuntimeError
is raised. If the generator raises any other exception, it is propagated to the caller.aclose()
does nothing if the generator has already exited due to an exception or normal exit.
- asend(value, /)#
Resumes the execution and “sends” a value into the async generator function.
The
value
argument becomes the result of the current yield expression. The awaitable returned by theasend()
method will return the next value yielded by the generator or raisesStopAsyncIteration
if the asynchronous generator returns. If the generator returned a value, this value is discarded (because in Python async generators cannot return a value).When
asend()
is called to start the generator, the argument will be ignored. Unlike in Python, we cannot detect that the generator hasn’t started yet, and no error will be thrown if the argument of a not-started generator is notNone
.- Parameters:
value (
T_contra
)- Return type:
Awaitable
[T_co
]
- athrow(error, /)#
Resumes the execution and raises an exception at the point where the generator was paused.
The awaitable returned by
athrow()
method will return the next value yielded by the generator or raisesStopAsyncIteration
if the asynchronous generator returns. If the generator returned a value, this value is discarded (because in Python async generators cannot return a value). If the generator function does not catch the passed-in exception, or raises a different exception, then that exception propagates to the caller.- Parameters:
error (
BaseException
)- Return type:
T_co
- class pyodide.ffi.JsAsyncIterable#
-
A JavaScript async iterable object
A JavaScript object is async iterable if it has a
Symbol.asyncIterator
method.
- class pyodide.ffi.JsAsyncIterator#
-
A JsProxy of a JavaScript async iterator.
An object is a
JsAsyncIterator
if it has anext()
method and either has aSymbol.asyncIterator
or has noSymbol.iterator
- class pyodide.ffi.JsBuffer#
Bases:
JsProxy
A JsProxy of an array buffer or array buffer view
- assign(rhs, /)#
Assign from a Python buffer into the JavaScript buffer.
- assign_to(to, /)#
Assign to a Python buffer from the JavaScript buffer.
- from_file(file, /)#
Reads from a file into a buffer.
Will try to read a chunk of data the same size as the buffer from the current position of the file.
Example
>>> None >>> from pathlib import Path >>> Path("file.bin").write_text("abc\x00123ttt") 10 >>> from js import Uint8Array >>> # the JsProxy need to be pre-allocated >>> x = Uint8Array.new(10) >>> with open('file.bin', 'rb') as fh: ... x.from_file(fh)
which is equivalent to
>>> x = Uint8Array.new(range(10)) >>> with open('file.bin', 'rb') as fh: ... chunk = fh.read(x.byteLength) ... x.assign(chunk)
but the latter copies the data twice whereas the former only copies the data once.
- to_file(file, /)#
Writes a buffer to a file.
Will write the entire contents of the buffer to the current position of the file.
Example
>>> from js import Uint8Array >>> from pathlib import Path >>> Path("file.bin").write_text("abc\x00123ttt") 10 >>> x = Uint8Array.new(range(10)) >>> with open('file.bin', 'wb') as fh: ... x.to_file(fh)
This is equivalent to
>>> with open('file.bin', 'wb') as fh: ... data = x.to_bytes() ... fh.write(data) 10
but the latter copies the data twice whereas the former only copies the data once.
- to_memoryview()#
Convert a buffer to a memoryview.
Copies the data once. This currently has the same effect as
to_py()
.- Return type:
- to_string(encoding=None)#
Convert a buffer to a string object.
Copies the data twice.
The encoding argument will be passed to the
TextDecoder
constructor. It should be one of the encodings listed in the table here. The default encoding is utf8.
- class pyodide.ffi.JsCallable#
-
A JavaScript callable
A JavaScript object is treated as a callable if typeof x returns “function”.
- class pyodide.ffi.JsDoubleProxy#
-
A double proxy created with
create_proxy()
.- unwrap()#
Unwrap a double proxy created with
create_proxy()
into the wrapped Python object.- Return type:
T
- exception pyodide.ffi.JsException(*args, **kwargs)#
-
A JavaScript Error.
These are pickleable unlike other JsProxies.
- class pyodide.ffi.JsFetchResponse#
Bases:
JsProxy
A
JsFetchResponse
object represents aResponse
to afetch()
request.
- class pyodide.ffi.JsGenerator#
Bases:
JsIterable
[T_co
],Generic
[T_co
,T_contra
,V_co
]A JavaScript generator
A JavaScript object is treated as a generator if its
Symbol.toStringTag
is"Generator"
. Most likely this will be because it is a trueGenerator
produced by the JavaScript runtime, but it may be a custom object trying hard to pretend to be a generator. It should havenext()
,return()
andthrow()
methods.- close()#
Raises a
GeneratorExit
at the point where the generator function was paused.If the generator function then exits gracefully, is already closed, or raises
GeneratorExit
(by not catching the exception),close()
returns to its caller. If the generator yields a value, aRuntimeError
is raised. If the generator raises any other exception, it is propagated to the caller.close()
does nothing if the generator has already exited due to an exception or normal exit.- Return type:
- send(value)#
Resumes the execution and “sends” a value into the generator function.
The
value
argument becomes the result of the current yield expression. Thesend()
method returns the next value yielded by the generator, or raisesStopIteration
if the generator exits without yielding another value. Whensend()
is called to start the generator, the argument will be ignored. Unlike in Python, we cannot detect that the generator hasn’t started yet, and no error will be thrown if the argument of a not-started generator is notNone
.- Parameters:
value (
T_contra
)- Return type:
T_co
- throw(error, /)#
Raises an exception at the point where the generator was paused, and returns the next value yielded by the generator function.
If the generator exits without yielding another value, a
StopIteration
exception is raised. If the generator function does not catch the passed-in exception, or raises a different exception, then that exception propagates to the caller.In typical use, this is called with a single exception instance similar to the way the raise keyword is used.
For backwards compatibility, however, a second signature is supported, following a convention from older versions of Python. The type argument should be an exception class, and value should be an exception instance. If the value is not provided, the type constructor is called to get an instance. If traceback is provided, it is set on the exception, otherwise any existing
__traceback__
attribute stored in value may be cleared.- Parameters:
error (
BaseException
)- Return type:
T_co
- class pyodide.ffi.JsIterable#
-
A JavaScript iterable object
A JavaScript object is iterable if it has a
Symbol.iterator
method.
- class pyodide.ffi.JsIterator#
-
A JsProxy of a JavaScript iterator.
An object is a
JsAsyncIterator
if it has anext()
method and either has aSymbol.iterator
or has noSymbol.asyncIterator
.
- class pyodide.ffi.JsMap#
Bases:
JsIterable
[KT
],Generic
[KT
,VT_co
],Mapping
[KT
,VT_co
]A JavaScript Map
To be considered a map, a JavaScript object must have a
get
method, it must have asize
or alength
property which is a number (idiomatically it should be calledsize
) and it must be iterable.- get(key, default, /)#
If
key in self
, returnsself[key]
. Otherwise returnsdefault
.- Parameters:
key (
KT
)default (
Optional
[VT_co
])
- Return type:
VT_co
- values()#
Return a
ValuesView
for the map.- Return type:
ValuesView
[VT_co
]
- class pyodide.ffi.JsMutableMap#
Bases:
JsMap
[KT
,VT
],Generic
[KT
,VT
],MutableMapping
[KT
,VT
]A JavaScript mutable map
To be considered a mutable map, a JavaScript object must have a
get
method, ahas
method, asize
or alength
property which is a number (idiomatically it should be calledsize
) and it must be iterable.Instances of the JavaScript builtin
Map
class areJsMutableMap
s. Also proxies returned byJsProxy.as_object_map()
are instances ofJsMap
.- pop(key, default=None, /)#
If
key in self
, returnself[key]
and remove key fromself
. Otherwise returnsdefault
.- Parameters:
key (
KT
)default (
Optional
[VT
])
- Return type:
VT
- popitem()#
Remove some arbitrary
key, value
pair from the map and returns the(key, value)
tuple.- Return type:
tuple
[KT
,VT
]
- setdefault(key, default=None)#
If
key in self
, returnself[key]
. Otherwise setsself[key] = default
and returnsdefault
.- Parameters:
key (
KT
)default (
Optional
[VT
])
- Return type:
VT
- update(other=None, /, **kwargs)#
Updates
self
fromother
andkwargs
.- Parameters:
- Return type:
If
other
is present and is aMapping
or has akeys
method, doesfor k in other: self[k] = other[k]
If
other
is present and lacks akeys
method, doesfor (k, v) in other: self[k] = v
In all cases this is followed by:
for (k, v) in kwargs.items(): self[k] = v
- class pyodide.ffi.JsOnceCallable#
Bases:
JsCallable
[P
,T
],Generic
[P
,T
]A JavaScript handle for a Python function which can be called at most once.
After it is called, the reference to the underlying Python object is released and attempting to call it again will raise an Error.
- class pyodide.ffi.JsPromise#
-
A
JsProxy
of aPromise
or some other thenable JavaScript object.A JavaScript object is considered to be a
Promise
if it has athen
method.- catch(onrejected, /)#
The
Promise.catch()
API, wrapped to manage the lifetimes of the handler.Pyodide will automatically release the references to the handler when the promise resolves.
- Parameters:
onrejected (
Callable
[[BaseException
],Union
[Awaitable
[S
],S
]])- Return type:
JsPromise
[S
]
- finally_(onfinally, /)#
The
Promise.finally()
API, wrapped to manage the lifetimes of the handler.Pyodide will automatically release the references to the handler when the promise resolves. Note the trailing underscore in the name; this is needed because
finally
is a reserved keyword in Python.
- then(onfulfilled, onrejected=None, /)#
The
Promise.then()
API, wrapped to manage the lifetimes of the handlers. Pyodide will automatically release the references to the handlers when the promise resolves.
- class pyodide.ffi.JsProxy#
Bases:
object
A proxy to make a JavaScript object behave like a Python object
For more information see the Type translations documentation. In particular, see the list of __dunder__ methods that are (conditionally) implemented on
JsProxy
.- as_object_map(*, hereditary=False)#
Returns a new JsProxy that treats the object as a map.
The methods
__getitem__()
,__setitem__()
,__contains__()
,__len__()
, etc will perform lookups viaobject[key]
or similar.Note that
len(x.as_object_map())
evaluates in O(n) time (it iterates over the object and counts how manyownKeys()
it has). If you need to compute the length in O(1) time, use a realMap
instead.- Parameters:
hereditary (
bool
) – IfTrue
, any “plain old objects” stored as values in the object will be wrapped in as_object_map themselves.- Return type:
Examples
>>> from pyodide.code import run_js >>> o = run_js("({x : {y: 2}})")
Normally you have to access the properties of
o
as attributes:>>> o.x.y 2 >>> o["x"] # is not subscriptable Traceback (most recent call last): TypeError: 'pyodide.ffi.JsProxy' object is not subscriptable
as_object_map
allows us to access the property withgetitem
:>>> o.as_object_map()["x"].y 2
The inner object is not subscriptable because
hereditary
isFalse
:>>> o.as_object_map()["x"]["y"] Traceback (most recent call last): TypeError: 'pyodide.ffi.JsProxy' object is not subscriptable
When
hereditary
isTrue
, the inner object is also subscriptable:>>> o.as_object_map(hereditary=True)["x"]["y"] 2
- as_py_json()#
Returns a new JsProxy that treats a JavaScript object as Python json.
It allows one to treat a JavaScript object that is a mixture of JavaScript arrays and objects as a mixture of Python lists and dicts.
This method is not present on typed arrays, array buffers, functions, and errors.
Examples
>>> from pyodide.code import run_js >>> o1 = run_js("({x : {y: 2}})") >>> o1.as_py_json()["x"]["y"] 2 >>> o2 = run_js("[{x: 2}, {x: 7}]") >>> [e["x"] for e in o2.as_py_json()] [2, 7]
You can use the following converter as the default argument to
json.dumps()
to serialize a JavaScript object with>>> from pyodide.ffi import JsProxy >>> def default(obj): ... if isinstance(obj, JsProxy): ... if obj.constructor.name == "Array": ... return list(obj) ... return dict(obj)
For example:
>>> import json >>> json.dumps(o1.as_py_json(), default=default) '{"x": {"y": 2}}' >>> json.dumps(o2.as_py_json(), default=default) '[{"x": 2}, {"x": 7}]'
If you load the resulting json back into Python, the result is the same as calling
JsProxy.to_py()
:>>> assert json.loads(json.dumps(o1.as_py_json(), default=default)) == o1.to_py() >>> assert json.loads(json.dumps(o2.as_py_json(), default=default)) == o2.to_py()
- bind_sig(signature)#
Creates a copy of the JsProxy with a signature bound to it.
Experimental
This feature is not yet stable, nor really documented.
- Parameters:
signature (
T
)- Return type:
T
- js_id: int#
An id number which can be used as a dictionary/set key if you want to key on JavaScript object identity.
If two
JsProxy
are made with the same backing JavaScript object, they will have the samejs_id
.
- new(*args, **kwargs)#
Construct a new instance of the JavaScript object
- object_entries()#
The JavaScript API
Object.entries(object)
Examples
>>> from pyodide.code import run_js >>> js_obj = run_js("({first: 'aa', second: 22})") >>> entries = js_obj.object_entries() >>> [(key, val) for key, val in entries] [('first', 'aa'), ('second', 22)]
- object_keys()#
The JavaScript API
Object.keys(object)
Examples
>>> from pyodide.code import run_js >>> js_obj = run_js("({first: 1, second: 2, third: 3})") >>> keys = js_obj.object_keys() >>> list(keys) ['first', 'second', 'third']
- object_values()#
The JavaScript API
Object.values(object)
Examples
>>> from pyodide.code import run_js >>> js_obj = run_js("({first: 1, second: 2, third: 3})") >>> values = js_obj.object_values() >>> list(values) [1, 2, 3]
- to_py(*, depth=-1, default_converter=None)#
Convert the
JsProxy
to a native Python object as best as possible.See JavaScript to Python for more information.
- Parameters:
depth (
int
) – Limit the depth of the conversion. If a shallow conversion is desired, setdepth
to 1.default_converter (
Callable
[[JsProxy
,Callable
[[JsProxy
],Any
],Callable
[[JsProxy
,Any
],None
]],Any
] |None
) – If present, this will be invoked whenever Pyodide does not have some built in conversion for the object. Ifdefault_converter
raises an error, the error will be allowed to propagate. Otherwise, the object returned will be used as the conversion.default_converter
takes three arguments. The first argument is the value to be converted.
- Return type:
Examples
Here are a couple examples of converter functions. In addition to the normal conversions, convert
Date
todatetime
:from datetime import datetime def default_converter(value, _ignored1, _ignored2): if value.constructor.name == "Date": return datetime.fromtimestamp(d.valueOf()/1000) return value
Don’t create any JsProxies, require a complete conversion or raise an error:
def default_converter(_value, _ignored1, _ignored2): raise Exception("Failed to completely convert object")
The second and third arguments are only needed for converting containers. The second argument is a conversion function which is used to convert the elements of the container with the same settings. The third argument is a “cache” function which is needed to handle self referential containers. Consider the following example. Suppose we have a Javascript
Pair
class:class Pair { constructor(first, second){ this.first = first; this.second = second; } }
We can use the following
default_converter
to convertPair
tolist
:def default_converter(value, convert, cache): if value.constructor.name != "Pair": return value result = [] cache(value, result); result.append(convert(value.first)) result.append(convert(value.second)) return result
Note that we have to cache the conversion of
value
before convertingvalue.first
andvalue.second
. To see why, consider a self referential pair:let p = new Pair(0, 0); p.first = p;
Without
cache(value, result);
, convertingp
would lead to an infinite recurse. With it, we can successfully convertp
to a list such thatl[0] is l
.
- pyodide.ffi.create_once_callable(obj, /)#
Wrap a Python Callable in a JavaScript function that can be called once.
After being called the proxy will decrement the reference count of the Callable. The JavaScript function also has a
destroy
API that can be used to release the proxy without calling it.- Parameters:
- Return type:
- pyodide.ffi.create_proxy(obj, /, *, capture_this=False, roundtrip=True)#
Create a
JsProxy
of aPyProxy
.This allows explicit control over the lifetime of the
PyProxy
from Python: call thedestroy()
API when done.- Parameters:
obj (
T
) – The object to wrap.capture_this (
bool
) – If the object is callable, shouldthis
be passed as the first argument when calling it from JavaScript.roundtrip (
bool
) –When the proxy is converted back from JavaScript to Python, if this is
True
it is converted into a double proxy. IfFalse
, it is unwrapped into a Python object. In the case thatroundtrip
isTrue
it is possible to unwrap a double proxy with theJsDoubleProxy.unwrap()
method. This is useful to allow easier control of lifetimes from Python:from js import o d = {} o.d = create_proxy(d, roundtrip=True) o.d.destroy() # Destroys the proxy created with create_proxy
With
roundtrip=False
this would be an error.
- Return type:
- pyodide.ffi.destroy_proxies(pyproxies, /)#
Destroy all PyProxies in a JavaScript array.
pyproxies must be a JavaScript Array of PyProxies. Intended for use with the arrays created from the “pyproxies” argument of
toJs()
andto_js()
. This method is necessary because indexing the Array from Python automatically unwraps the PyProxy into the wrapped Python object.
- pyodide.ffi.register_js_module(name, jsproxy)#
Registers
jsproxy
as a JavaScript module namedname
. The module can then be imported from Python using the standard Python import system. If another module by the same name has already been imported, this won’t have much effect unless you also delete the imported module fromsys.modules
. This is called by the JavaScript APIpyodide.registerJsModule()
.
- pyodide.ffi.run_sync(x)#
Block until an awaitable is resolved.
Only works if JS Promise integration is enabled in the runtime and the current Python call stack was entered via
pyodide.runPythonAsync()
, by calling an async Python function, or viacallPromising()
.Experimental
This feature is not yet stable.
- Parameters:
x (
Awaitable
[T
])- Return type:
T
- pyodide.ffi.to_js(obj, /, *, depth=-1, pyproxies=None, create_pyproxies=True, dict_converter=None, default_converter=None)#
Convert the object to JavaScript.
This is similar to
toJs()
, but for use from Python. If the object can be implicitly translated to JavaScript, it will be returned unchanged. If the object cannot be converted into JavaScript, this method will return aJsProxy
of aPyProxy
, as if you had usedcreate_proxy()
.See Python to JavaScript for more information.
- Parameters:
obj (
Any
) – The Python object to convertdepth (
int
) – The maximum depth to do the conversion. Negative numbers are treated as infinite. Set this to 1 to do a shallow conversion.pyproxies (
JsProxy
|None
) – Should be a JavaScriptArray
. If provided, anyPyProxies
generated will be stored here. You can later usedestroy_proxies()
if you want to destroy the proxies from Python (or from JavaScript you can just iterate over theArray
and destroy the proxies).create_pyproxies (
bool
) – If you set this toFalse
,to_js()
will raise an error rather than creating any pyproxies.dict_converter (
Callable
[[Iterable
[JsArray
[Any
]]],JsProxy
] |None
) –This converter if provided receives a (JavaScript) iterable of (JavaScript) pairs [key, value]. It is expected to return the desired result of the dict conversion. Some suggested values for this argument:
js.Map.new
– similar to the default behaviorjs.Array.from
– convert to an array of entriesjs.Object.fromEntries
– convert to a JavaScript object
default_converter (
Callable
[[Any
,Callable
[[Any
],JsProxy
],Callable
[[Any
,JsProxy
],None
]],JsProxy
] |None
) – If present will be invoked whenever Pyodide does not have some built in conversion for the object. Ifdefault_converter
raises an error, the error will be allowed to propagate. Otherwise, the object returned will be used as the conversion.default_converter
takes three arguments. The first argument is the value to be converted.
- Return type:
Examples
>>> from js import Object, Map, Array >>> from pyodide.ffi import to_js >>> js_object = to_js({'age': 20, 'name': 'john'}) >>> js_object [object Map] >>> js_object.keys(), js_object.values() KeysView([object Map]) ValuesView([object Map]) >>> [(k, v) for k, v in zip(js_object.keys(), js_object.values())] [('age', 20), ('name', 'john')]
>>> js_object = to_js({'age': 20, 'name': 'john'}, dict_converter=Object.fromEntries) >>> js_object.age == 20 True >>> js_object.name == 'john' True >>> js_object [object Object] >>> js_object.hasOwnProperty("age") True >>> js_object.hasOwnProperty("height") False
>>> js_object = to_js({'age': 20, 'name': 'john'}, dict_converter=Array.from_) >>> [item for item in js_object] [age,20, name,john] >>> js_object.toString() age,20,name,john
>>> class Bird: pass >>> converter = lambda value, convert, cache: Object.new(size=1, color='red') if isinstance(value, Bird) else None >>> js_nest = to_js([Bird(), Bird()], default_converter=converter) >>> [bird for bird in js_nest] [[object Object], [object Object]] >>> [(bird.size, bird.color) for bird in js_nest] [(1, 'red'), (1, 'red')]
Here are some examples demonstrating the usage of the
default_converter
argument.In addition to the normal conversions, convert JavaScript
Date
objects todatetime
objects:from datetime import datetime from js import Date def default_converter(value, _ignored1, _ignored2): if isinstance(value, datetime): return Date.new(value.timestamp() * 1000) return value
Don’t create any PyProxies, require a complete conversion or raise an error:
def default_converter(_value, _ignored1, _ignored2): raise Exception("Failed to completely convert object")
The second and third arguments are only needed for converting containers. The second argument is a conversion function which is used to convert the elements of the container with the same settings. The third argument is a “cache” function which is needed to handle self referential containers. Consider the following example. Suppose we have a Python
Pair
class:class Pair: def __init__(self, first, second): self.first = first self.second = second
We can use the following
default_converter
to convertPair
toArray
:from js import Array def default_converter(value, convert, cache): if not isinstance(value, Pair): return value result = Array.new() cache(value, result) result.push(convert(value.first)) result.push(convert(value.second)) return result
Note that we have to cache the conversion of
value
before convertingvalue.first
andvalue.second
. To see why, consider a self referential pair:p = Pair(0, 0); p.first = p;
Without
cache(value, result);
, convertingp
would lead to an infinite recurse. With it, we can successfully convertp
to an Array such thatl[0] === l
.
- pyodide.ffi.unregister_js_module(name)#
Unregisters a JavaScript module with given name that has been previously registered with
pyodide.registerJsModule()
orpyodide.ffi.register_js_module()
. If a JavaScript module with that name does not already exist, will raise an error. If the module has already been imported, this won’t have much effect unless you also delete the imported module fromsys.modules
. This is called by the JavaScript APIpyodide.unregisterJsModule()
.
Functions:
|
Wrapper for JavaScript's |
|
Wrapper for JavaScript's |
|
Wrapper for JavaScript's |
|
Wrapper for JavaScript's |
|
Wrapper for JavaScript's |
|
Wrapper for JavaScript's |
- pyodide.ffi.wrappers.add_event_listener(elt, event, listener)#
Wrapper for JavaScript’s
addEventListener()
which automatically manages the lifetime of a JsProxy corresponding to thelistener
parameter.
- pyodide.ffi.wrappers.clear_interval(interval_retval)#
Wrapper for JavaScript’s
clearInterval()
which automatically manages the lifetime of a JsProxy corresponding to thecallback
parameter.
- pyodide.ffi.wrappers.clear_timeout(timeout_retval)#
Wrapper for JavaScript’s
clearTimeout()
which automatically manages the lifetime of a JsProxy corresponding to thecallback
parameter.
- pyodide.ffi.wrappers.remove_event_listener(elt, event, listener)#
Wrapper for JavaScript’s
removeEventListener()
which automatically manages the lifetime of a JsProxy corresponding to thelistener
parameter.
- pyodide.ffi.wrappers.set_interval(callback, interval)#
Wrapper for JavaScript’s
setInterval()
which automatically manages the lifetime of a JsProxy corresponding to thecallback
parameter.