Merge pull request #76 from Distributive-Network/Xmader/fix/JSObjectProxy-as-dict

make JSObjectProxy function as a dict

Author: Xmader

include/JSObjectProxy.hh

@@ -112,6 +112,22 @@ public:
    * @return bool - Whether the compared objects are equal or not
    */
   static bool JSObjectProxy_richcompare_helper(JSObjectProxy *self, PyObject *other, std::unordered_map<PyObject *, PyObject *> &visited);
+
+  /**
+   * @brief Return an iterator object to make JSObjectProxy iterable, emitting (key, value) tuples
+   *
+   * @param self - The JSObjectProxy
+   * @return PyObject* - iterator object
+   */
+  static PyObject *JSObjectProxy_iter(JSObjectProxy *self);
+
+  /**
+   * @brief Compute a string representation of the JSObjectProxy
+   *
+   * @param self - The JSObjectProxy
+   * @return the string representation (a PyUnicodeObject) on success, NULL on failure
+   */
+  static PyObject *JSObjectProxy_repr(JSObjectProxy *self);
 };
 
 

include/PyProxyHandler.hh

@@ -181,4 +181,9 @@ public:
   bool delete_(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, JS::ObjectOpResult &result) const override;
 };
 
+/**
+ * @brief Convert jsid to a PyObject to be used as dict keys
+ */
+PyObject *idToKey(JSContext *cx, JS::HandleId id);
+
 #endif

include/pyTypeFactory.hh

@@ -36,6 +36,11 @@ PyType *pyTypeFactory(PyObject *object);
  * @return PyType* - Pointer to a PyType object corresponding to the JS::Value
  */
 PyType *pyTypeFactory(JSContext *cx, JS::Rooted<JSObject *> *thisObj, JS::Rooted<JS::Value> *rval);
+/**
+ * @brief same to pyTypeFactory, but it's guaranteed that no error would be set on the Python error stack, instead
+ * return `pythonmonkey.null` on error
+ */
+PyType *pyTypeFactorySafe(JSContext *cx, JS::Rooted<JSObject *> *thisObj, JS::Rooted<JS::Value> *rval);
 
 /**
  * @brief Helper function for pyTypeFactory to create FuncTypes through PyCFunction_New

python/pythonmonkey/__init__.py

@@ -9,3 +9,18 @@
 # Load the module by default to make `console`/`atob`/`btoa` globally available
 require("console")
 require("base64")
+
+# Add the `.keys()` method on `Object.prototype` to get JSObjectProxy dict() conversion working
+# Conversion from a dict-subclass to a strict dict by `dict(subclass)` internally calls the .keys() method to read the dictionary keys, 
+# but .keys on a JSObjectProxy can only come from the JS side
+pm.eval("""
+(makeList) => {
+  const keysMethod = {
+    get() {
+      return () => makeList(...Object.keys(this))
+    }
+  }
+  Object.defineProperty(Object.prototype, "keys", keysMethod)
+  Object.defineProperty(Array.prototype, "keys", keysMethod)
+}
+""")(lambda *args: list(args))

src/JSObjectProxy.cc

@@ -14,6 +14,7 @@
 #include "include/modules/pythonmonkey/pythonmonkey.hh"
 #include "include/jsTypeFactory.hh"
 #include "include/pyTypeFactory.hh"
+#include "include/PyProxyHandler.hh"
 
 #include <jsapi.h>
 #include <jsfriendapi.h>
@@ -194,3 +195,58 @@ bool JSObjectProxyMethodDefinitions::JSObjectProxy_richcompare_helper(JSObjectPr
 
   return true;
 }
+
+PyObject *JSObjectProxyMethodDefinitions::JSObjectProxy_iter(JSObjectProxy *self) {
+  JSContext *cx = GLOBAL_CX;
+  JS::RootedObject *global = new JS::RootedObject(cx, JS::GetNonCCWObjectGlobal(self->jsObject));
+
+  // Get **enumerable** own properties
+  JS::RootedIdVector props(cx);
+  if (!js::GetPropertyKeys(cx, self->jsObject, JSITER_OWNONLY, &props)) {
+    return NULL;
+  }
+
+  // Populate a Python tuple with (propertyKey, value) pairs from the JS object
+  // Similar to `Object.entries()`
+  size_t length = props.length();
+  PyObject *seq = PyTuple_New(length);
+  for (size_t i = 0; i < length; i++) {
+    JS::HandleId id = props[i];
+    PyObject *key = idToKey(cx, id);
+
+    JS::RootedValue *jsVal = new JS::RootedValue(cx);
+    JS_GetPropertyById(cx, self->jsObject, id, jsVal);
+    PyObject *value = pyTypeFactory(cx, global, jsVal)->getPyObject();
+
+    PyTuple_SetItem(seq, i, PyTuple_Pack(2, key, value));
+  }
+
+  // Convert to a Python iterator
+  return PyObject_GetIter(seq);
+}
+
+PyObject *JSObjectProxyMethodDefinitions::JSObjectProxy_repr(JSObjectProxy *self) {
+  // Detect cyclic objects
+  PyObject *objPtr = PyLong_FromVoidPtr(self->jsObject.get());
+  // For `Py_ReprEnter`, we must get a same PyObject when visiting the same JSObject.
+  // We cannot simply use the object returned by `PyLong_FromVoidPtr` because it won't reuse the PyLongObjects for ints not between -5 and 256.
+  // Instead, we store this PyLongObject in a global dict, using itself as the hashable key, effectively interning the PyLongObject.
+  PyObject *tsDict = PyThreadState_GetDict();
+  PyObject *cyclicKey = PyDict_SetDefault(tsDict, /*key*/ objPtr, /*value*/ objPtr); // cyclicKey = (tsDict[objPtr] ??= objPtr)
+  int status = Py_ReprEnter(cyclicKey);
+  if (status != 0) { // the object has already been processed
+    return status > 0 ? PyUnicode_FromString("[Circular]") : NULL;
+  }
+
+  // Convert JSObjectProxy to a dict
+  PyObject *dict = PyDict_New();
+  // Update from the iterator emitting key-value pairs
+  //    see https://docs.python.org/3/c-api/dict.html#c.PyDict_MergeFromSeq2
+  PyDict_MergeFromSeq2(dict, JSObjectProxy_iter(self), /*override*/ false);
+  // Get the string representation of this dict
+  PyObject *str = PyObject_Repr(dict);
+
+  Py_ReprLeave(cyclicKey);
+  PyDict_DelItem(tsDict, cyclicKey);
+  return str;
+}

src/modules/pythonmonkey/pythonmonkey.cc

@@ -73,13 +73,15 @@ PyTypeObject JSObjectProxyType = {
   .tp_name = "pythonmonkey.JSObjectProxy",
   .tp_basicsize = sizeof(JSObjectProxy),
   .tp_dealloc = (destructor)JSObjectProxyMethodDefinitions::JSObjectProxy_dealloc,
+  .tp_repr = (reprfunc)JSObjectProxyMethodDefinitions::JSObjectProxy_repr,
   .tp_as_mapping = &JSObjectProxy_mapping_methods,
   .tp_getattro = (getattrofunc)JSObjectProxyMethodDefinitions::JSObjectProxy_get,
   .tp_setattro = (setattrofunc)JSObjectProxyMethodDefinitions::JSObjectProxy_assign,
   .tp_flags = Py_TPFLAGS_DEFAULT
   | Py_TPFLAGS_DICT_SUBCLASS,  // https://docs.python.org/3/c-api/typeobj.html#Py_TPFLAGS_DICT_SUBCLASS
   .tp_doc = PyDoc_STR("Javascript Object proxy dict"),
   .tp_richcompare = (richcmpfunc)JSObjectProxyMethodDefinitions::JSObjectProxy_richcompare,
+  .tp_iter = (getiterfunc)JSObjectProxyMethodDefinitions::JSObjectProxy_iter,
   .tp_base = &PyDict_Type,
   .tp_init = (initproc)JSObjectProxyMethodDefinitions::JSObjectProxy_init,
   .tp_new = JSObjectProxyMethodDefinitions::JSObjectProxy_new,

src/pyTypeFactory.cc

@@ -175,6 +175,17 @@ PyType *pyTypeFactory(JSContext *cx, JS::Rooted<JSObject *> *thisObj, JS::Rooted
   return NULL;
 }
 
+PyType *pyTypeFactorySafe(JSContext *cx, JS::Rooted<JSObject *> *thisObj, JS::Rooted<JS::Value> *rval) {
+  PyType *v = pyTypeFactory(cx, thisObj, rval);
+  if (PyErr_Occurred()) {
+    // Clear Python error
+    PyErr_Clear();
+    // Return `pythonmonkey.null` on error
+    return new NullType();
+  }
+  return v;
+}
+
 PyObject *callJSFunc(PyObject *jsCxThisFuncTuple, PyObject *args) {
   // TODO (Caleb Aikens) convert PyObject *args to JS::Rooted<JS::ValueArray> JSargs
   JSContext *cx = (JSContext *)PyLong_AsVoidPtr(PyTuple_GetItem(jsCxThisFuncTuple, 0));

tests/python/test_dicts_lists.py

@@ -73,6 +73,30 @@ def test_eval_objects_proxy_proto():
     assert pm.null == pm.eval("(o) => Object.getPrototypeOf(o)")({})
     assert pm.null == pm.eval("(o) => Object.getPrototypeOf(o)")({ "abc": 1 })
 
+def test_eval_objects_proxy_iterate():
+    obj = pm.eval("({ a: 123, b: 'test' })")
+    result = []
+    for i in obj:
+        result.append(i)
+    assert result == [('a', 123.0), ('b', 'test')]
+
+def test_eval_objects_proxy_repr():
+    obj = pm.eval("({ a: 123, b: 'test' , c: { d: 1 }})")
+    obj.e = obj # supporting circular references
+    expected = "{'a': 123.0, 'b': 'test', 'c': {'d': 1.0}, 'e': [Circular]}"
+    assert repr(obj) == expected
+    assert str(obj) == expected
+
+def test_eval_objects_proxy_dict_conversion():
+    obj = pm.eval("({ a: 123, b: 'test' , c: { d: 1 }})")
+    d = dict(obj)
+    assert type(obj) is not dict # dict subclass
+    assert type(d) is dict # strict dict
+    assert repr(d) == "{'a': 123.0, 'b': 'test', 'c': {'d': 1.0}}"
+    assert obj.keys() == ['a', 'b', 'c'] # Conversion from a dict-subclass to a strict dict internally calls the .keys() method
+    assert list(d.keys()) == obj.keys()
+    assert obj == d
+
 def test_eval_objects_jsproxy_get():
     proxy = pm.eval("({a: 1})")
     assert 1.0 == proxy['a']