PyObject | /mod.ts | python@0.4.1

class PyObject

import { PyObject } from "https://deno.land/x/python@0.4.1/mod.ts";

Represents a Python object.

It can be anything, like an int, a string, a list, a dict, etc. and even a module itself.

Normally, you will deal with proxied PyObjects, which are basically JS objects but the get, set, etc. methods you perform on them are actually proxied to Python interpreter API.

In case you need access to actual PyObject (which this module does too, internally), there's a Symbol on Proxied PyObjects ProxiedPyObject that is exported from this module too. It contains reference to PyObject.

Both proxied PyObject and normal PyObject implement some basic methods like valueOf, toString and Deno inspect to provide pretty-printing, and also a way to cast Python values as JS types using valueOf. For caveats on valueOf, see its documentation.

Do not construct this manually, as it takes an Unsafe Pointer pointing to the C PyObject.

Constructors

new

PyObject(handle: Deno.PointerValue)

Properties

readonly

isNone

Check if the object is NULL (pointer) or None type in Python.

readonly

owned: PyObject

Increases ref count of the object and returns it.

readonly

proxy: any

Creates proxy object that maps basic JS operations on objects such as gets, sets, function calls, has, etc. to Python interpreter API. This makes using Python APIs in JS less cumbersome.

Usually, you will deal with proxied PyObjects because they're easier to interact with. If you somehow need the actual PyObject, refer to it's documentation.

To keep it consistent, proxied objects' further get calls return proxy objects only, so you can safely chain them. But for instance, if you made a call to a method that returns a Python list using proxy object, you can call .valueOf() on it to turn it into a JS Array.

What you can do on proxy objects:

Call them, if they are a function. An error will be thrown otherwise.
Get their attributes. Such as get lower attribute on a str object. This same thing is used to get values of given gets in dicts as well. But the thing is, preference is given to attributes, if its not found, then we try to look for dict key. We could not differentiate normal property access like something.property with something[indexed] in JS, so they are done on same thing. In case this is not viable for you, you can call the get method on the proxy object, which maps to dict's get method of course. Just like dicts, this works for lists/tuples too - in order to return elements based on index. In special cases, this get accessor returns actual proxy methods, such as toString, valueOf, etc. Either way, preference is given to Python object first. So only if they do not have these attributes, we return the JS functions.
Set their attributes. Same as the "get" proxy behavior described above, but instead to set attribute / dict key / list index.
There's also this has accessor on proxy objects, which is basically like in operator in Python. It checks if attribute/dict key exists in the object.