Add PyProxy dict support

Author: hoodmane

Lib/test/test_pyodide.py

@@ -397,6 +397,34 @@ class T:
         )
         self.assertGreaterEqual(l, {"a", "b"})
 
+    def test_pyproxy_dict(self):
+        d = {"a": 7, "b": 2, 3: "99"}
+        l = set(
+            x
+            for x in run_js("(o) => Reflect.ownKeys(o)")(d)
+            if isinstance(x, str)
+        )
+        self.assertGreaterEqual(l, {"a", "b", "3"})
+
+        self.assertEqual(run_js("(o) => o.get('a')")(d), 7)
+        self.assertEqual(run_js("(o) => o.get(3)")(d), "99")
+        self.assertEqual(run_js("(o) => o.get('3')")(d), None)
+        self.assertEqual(run_js("(o) => o.a")(d), 7)
+        self.assertEqual(run_js("(o) => o['a']")(d), 7)
+        self.assertEqual(run_js("(o) => o[3]")(d), "99")
+
+        run_js("(o) => delete o[3]")(d)
+        self.assertNotIn(3, d)
+        run_js("(o) => o.delete('b')")(d)
+        self.assertNotIn("b", d)
+        run_js("(o) => o.z = 9")(d)
+        self.assertEqual(d["z"], 9)
+        run_js("(o) => o.set('q', 32)")(d)
+        self.assertEqual(d["q"], 32)
+
+        # TODO:
+        # self.assertEqual(list(run_js("(o) => o.items()")(d)), [])
+
     def test_pyproxy_call_simple(self):
         def f(x):
             return x * x + 7
@@ -500,9 +528,7 @@ def test_pyproxy_set_del(self):
 
     def test_pyproxy_iterable(self):
         d = [7, 21, 39]
-        res = list(
-            run_js("(d) => Array.from(d)")(d)
-        )
+        res = list(run_js("(d) => Array.from(d)")(d))
         self.assertEqual(res, d)
 
     def test_pyproxy_iterator(self):

Modules/_pyodide_core/pyproxy.c

@@ -12,6 +12,7 @@
 #define HAS_LENGTH             (1 << 2)
 #define HAS_SET                (1 << 3)
 #define IS_CALLABLE            (1 << 4)
+#define IS_DICT                (1 << 5)
 #define IS_ITERABLE            (1 << 7)
 #define IS_ITERATOR            (1 << 8)
 
@@ -82,6 +83,7 @@ type_getflags(PyTypeObject* obj_type)
   SET_FLAG_IF(HAS_LENGTH, seq_proto->sq_length || map_proto->mp_length);
   SET_FLAG_IF(HAS_SET, map_proto->mp_ass_subscript || seq_proto->sq_ass_item);
   SET_FLAG_IF(IS_CALLABLE, obj_type->tp_call);
+  SET_FLAG_IF(IS_DICT, Py_Is(obj_type, &PyDict_Type));
   SET_FLAG_IF(IS_ITERABLE, obj_type->tp_iter || seq_proto->sq_item);
 
   extern PyObject* _PyObject_NextNotImplemented(PyObject *);

Modules/_pyodide_core/pyproxy.ts

@@ -52,14 +52,10 @@ declare function __pyproxyGen_Send(ptr: number, arg: any): IteratorResult<any>
 // This also has the benefit that it makes intellisense happy.
 declare var HAS_CONTAINS: number;
 declare var HAS_GET: number;
-declare var HAS_HAS: number;
-declare var HAS_INCLUDES: number;
 declare var HAS_LENGTH: number;
 declare var HAS_SET: number;
-declare var IS_ARRAY: number;
 declare var IS_CALLABLE: number;
-declare var IS_ERROR: number;
-declare var IS_GENERATOR: number;
+declare var IS_DICT: number;
 declare var IS_ITERABLE: number;
 declare var IS_ITERATOR: number;
 
@@ -187,6 +183,7 @@ function pyproxy_new(
   if (flags === -1) {
     _pythonexc2js();
   }
+  const is_dict = flags & IS_DICT;
   const cls = getPyProxyClass(flags);
   let target: any;
   if (flags & IS_CALLABLE) {
@@ -234,7 +231,11 @@ function pyproxy_new(
     props,
   );
   let handlers;
-  handlers = PyProxyHandlers;
+  if (is_dict) {
+    handlers = PyProxyDictHandlers;
+  } else {
+    handlers = PyProxyHandlers;
+  }
   let proxy = new Proxy(target, handlers);
   if (!isAlias && gcRegister) {
     // we need to register only once for a set of aliases. we can't register the
@@ -583,6 +584,138 @@ const PyProxyHandlers = {
 };
 
 
+
+const PyProxyDictHandlersSet = new Set([
+  "copy",
+  "constructor",
+  "$$flags",
+  "toString",
+  "destroy",
+]);
+
+interface PythonError {
+  type: string;
+}
+
+function isPythonError(e: any): e is PythonError {
+  return (
+    e &&
+    typeof e === "object" &&
+    e.constructor &&
+    e.constructor.name === "PythonError"
+  );
+}
+
+const PyProxyDictHandlers = {
+  isExtensible(): boolean {
+    return true;
+  },
+  has(jsobj: PyProxy, jskey: string | symbol): boolean {
+    if (PyContainsMethods.prototype.has.call(jsobj, jskey)) {
+      return true;
+    }
+    if (typeof jskey === "string" && /^[0-9]+$/.test(jskey)) {
+      return PyContainsMethods.prototype.has.call(jsobj, Number(jskey));
+    }
+    return false;
+  },
+  get(jsobj: PyProxy, jskey: string | symbol): any {
+    if (
+      typeof jskey === "symbol" ||
+      PyProxyDictHandlersSet.has(jskey)
+    ) {
+      // @ts-ignore
+      return Reflect.get(...arguments);
+    }
+    const result = PyGetItemMethods.prototype.get.call(jsobj, jskey);
+    if (
+      result !== undefined ||
+      PyContainsMethods.prototype.has.call(jsobj, jskey)
+    ) {
+      return result;
+    }
+    if (typeof jskey === "string" && /^[0-9]+$/.test(jskey)) {
+      return PyGetItemMethods.prototype.get.call(jsobj, Number(jskey));
+    }
+    // @ts-ignore
+    return Reflect.get(...arguments);
+  },
+  set(jsobj: PyProxy, jskey: string | symbol | number, jsval: any): boolean {
+    if (typeof jskey === "symbol") {
+      return false;
+    }
+    if (
+      !PyContainsMethods.prototype.has.call(jsobj, jskey) &&
+      typeof jskey === "string" &&
+      /^[0-9]+$/.test(jskey)
+    ) {
+      jskey = Number(jskey);
+    }
+    try {
+      PySetItemMethods.prototype.set.call(jsobj, jskey, jsval);
+      return true;
+    } catch (e) {
+      if (isPythonError(e) && e.type === "KeyError") {
+        return false;
+      }
+      throw e;
+    }
+  },
+  deleteProperty(jsobj: PyProxy, jskey: string | symbol | number): boolean {
+    if (typeof jskey === "symbol") {
+      return false;
+    }
+    if (
+      !PyContainsMethods.prototype.has.call(jsobj, jskey) &&
+      typeof jskey === "string" &&
+      /^[0-9]+$/.test(jskey)
+    ) {
+      jskey = Number(jskey);
+    }
+    try {
+      PySetItemMethods.prototype.delete.call(jsobj, jskey);
+      return true;
+    } catch (e) {
+      if (isPythonError(e) && e.type === "KeyError") {
+        return false;
+      }
+      throw e;
+    }
+  },
+  getOwnPropertyDescriptor(jsobj: PyProxy, prop: any) {
+    if (!PyProxyDictHandlers.has(jsobj, prop)) {
+      return undefined;
+    }
+    const value = PyProxyDictHandlers.get(jsobj, prop);
+    return {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true,
+    };
+  },
+  ownKeys(jsobj: PyProxy): (string | symbol)[] {
+    const result: Set<string | symbol> = new Set();
+    dictOwnKeysHelper(jsobj, result);
+    return Array.from(result);
+  },
+};
+
+function dictOwnKeysHelper(jsobj: PyProxy, result: Set<string | symbol>): void {
+  const dictKeysView: Iterable<any> & PyProxy = PyProxyHandlers.get(
+    jsobj,
+    "keys",
+  )();
+  for (const key of dictKeysView) {
+    if (typeof key === "string") {
+      result.add(key);
+    } else if (typeof key === "number") {
+      result.add(key.toString());
+    }
+  }
+  dictKeysView.destroy();
+}
+
 // Another layer of boilerplate. The PyProxyHandlers have some annoying logic to
 // deal with straining out the spurious "Function" properties "prototype",
 // "arguments", and "length", to deal with correctly satisfying the Proxy