feat(extension) Replace instance.exports['sum'](1, 2) by instance.exports.sum(1, 2).

Author: Hywan

README.md

@@ -60,7 +60,7 @@ from wasmer import Instance, Value
 
 wasm_bytes = open('simple.wasm', 'rb').read()
 instance = Instance(wasm_bytes)
-result = instance.exports['sum'](5, 37)
+result = instance.exports.sum(5, 37)
 
 print(result) # 42!
 ```
@@ -88,18 +88,17 @@ wasm_bytes = open('my_program.wasm', 'rb').read()
 instance = Instance(wasm_bytes)
 
 # Call a function on it.
-result = instance.exports['sum'](1, 2)
+result = instance.exports.sum(1, 2)
 
 print(result) # 3
 ```
 
-All exported functions are accessible in the `exports`
-dictionnary. Each value of this dictionnary is a function. Arguments
-of these functions are automatically casted to WebAssembly value. If
-one wants to explicitely pass a value of a particular type, it is
-possible to use the `Value` class,
-e.g. `instance.exports['sum'](Value.i32(1), Value.i32(2))`. Note that
-for most usecases, this is not necessary.
+All exported functions are accessible on the `exports` getter.
+Arguments of these functions are automatically casted to WebAssembly
+values. If one wants to explicitely pass a value of a particular type,
+it is possible to use the `Value` class,
+e.g. `instance.exports.sum(Value.i32(1), Value.i32(2))`. Note that for
+most usecases, this is not necessary.
 
 ### The `Value` class
 
@@ -169,7 +168,7 @@ wasm_bytes = open('my_program.wasm', 'rb').read()
 instance = Instance(wasm_bytes)
 
 # Call a function that returns a pointer to a string for instance.
-pointer = instance.exports['return_string']()
+pointer = instance.exports.return_string()
 
 # Get the memory view, with the offset set to `pointer` (default is 0).
 memory = instance.uint8_memory_view(pointer)

examples/memory.py

@@ -5,7 +5,7 @@
 
 wasm_bytes = open(__dir__ + '/memory.wasm', 'rb').read()
 instance = Instance(wasm_bytes)
-pointer = instance.exports['return_hello']()
+pointer = instance.exports.return_hello()
 
 memory = instance.uint8_memory_view(pointer)
 nth = 0;

examples/simple.py

@@ -5,6 +5,7 @@
 
 wasm_bytes = open(__dir__ + '/simple.wasm', 'rb').read()
 instance = Instance(wasm_bytes)
-result = instance.exports['sum'](5, 37)
+
+result = instance.exports.sum(1, 2)
 
 print(result) # 42!

src/instance.rs

@@ -2,10 +2,11 @@
 
 use crate::{memory_view, value::Value};
 use pyo3::{
-    exceptions::RuntimeError,
+    class::basic::PyObjectProtocol,
+    exceptions::{LookupError, RuntimeError},
     prelude::*,
-    types::{PyAny, PyBytes, PyDict, PyFloat, PyLong, PyTuple},
-    PyNativeType, PyTryFrom,
+    types::{PyAny, PyBytes, PyFloat, PyLong, PyTuple},
+    PyNativeType, PyTryFrom, ToPyObject,
 };
 use std::rc::Rc;
 use wasmer_runtime::{self as runtime, imports, instantiate, Export, Memory, Value as WasmValue};
@@ -91,10 +92,37 @@ impl ExportedFunction {
     }
 }
 
+#[pyclass]
+pub struct ExportedFunctions {
+    instance: Rc<runtime::Instance>,
+    functions: Vec<String>,
+}
+
+#[pyproto]
+impl PyObjectProtocol for ExportedFunctions {
+    fn __getattr__(&self, key: String) -> PyResult<ExportedFunction> {
+        if self.functions.contains(&key) {
+            Ok(ExportedFunction {
+                function_name: key,
+                instance: self.instance.clone(),
+            })
+        } else {
+            Err(LookupError::py_err(format!(
+                "Function `{}` does not exist.",
+                key
+            )))
+        }
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("{:?}", self.functions))
+    }
+}
+
 #[pyclass]
 pub struct Instance {
     instance: Rc<runtime::Instance>,
-    exports: PyObject,
+    exports: Py<ExportedFunctions>,
 }
 
 #[pymethods]
@@ -114,39 +142,33 @@ impl Instance {
         };
 
         let py = object.py();
-        let dict = PyDict::new(py);
+        let mut exported_functions = Vec::new();
 
         for (export_name, export) in instance.exports() {
             if let Export::Function { .. } = export {
-                dict.set_item(
-                    export_name.clone(),
-                    Py::new(
-                        py,
-                        ExportedFunction {
-                            function_name: export_name,
-                            instance: instance.clone(),
-                        },
-                    )?,
-                )?;
+                exported_functions.push(export_name);
             }
         }
 
         object.init({
             Self {
-                instance,
-                exports: dict.to_object(py),
+                instance: instance.clone(),
+                exports: Py::new(
+                    py,
+                    ExportedFunctions {
+                        instance: instance.clone(),
+                        functions: exported_functions,
+                    },
+                )?,
             }
         });
 
         Ok(())
     }
 
     #[getter]
-    fn exports(&self) -> PyResult<&PyDict> {
-        let gil = Python::acquire_gil();
-        let py = gil.python();
-
-        Ok(self.exports.cast_as::<PyDict>(py)?)
+    fn exports(&self) -> PyResult<&Py<ExportedFunctions>> {
+        Ok(&self.exports)
     }
 
     #[args(offset = 0)]

tests/instance.py

@@ -25,66 +25,66 @@ def test_failed_to_instantiate(self):
         )
 
     def test_function_does_not_exist(self):
-        with self.assertRaises(KeyError) as context_manager:
-            Instance(TEST_BYTES).exports['foo']
+        with self.assertRaises(LookupError) as context_manager:
+            Instance(TEST_BYTES).exports.foo
 
         exception = context_manager.exception
         self.assertEqual(
             str(exception),
-            "'foo'"
+            "Function `foo` does not exist."
         )
 
     def test_basic_sum(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['sum'](1, 2),
+            Instance(TEST_BYTES).exports.sum(1, 2),
             3
         )
 
     def test_call_arity_0(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['arity_0'](),
+            Instance(TEST_BYTES).exports.arity_0(),
             42
         )
 
     def test_call_i32_i32(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['i32_i32'](7),
+            Instance(TEST_BYTES).exports.i32_i32(7),
             7
         )
 
     def test_call_i64_i64(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['i64_i64'](7),
+            Instance(TEST_BYTES).exports.i64_i64(7),
             7
         )
 
     def test_call_f32_f32(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['f32_f32'](7.),
+            Instance(TEST_BYTES).exports.f32_f32(7.),
             7.
         )
 
     def test_call_f64_f64(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['f64_f64'](7.),
+            Instance(TEST_BYTES).exports.f64_f64(7.),
             7.
         )
 
     def test_call_i32_i64_f32_f64_f64(self):
         self.assertEqual(
-            round(Instance(TEST_BYTES).exports['i32_i64_f32_f64_f64'](1, 2, 3.4, 5.6), 6),
+            round(Instance(TEST_BYTES).exports.i32_i64_f32_f64_f64(1, 2, 3.4, 5.6), 6),
             1 + 2 + 3.4 + 5.6
         )
 
     def test_call_bool_casted_to_i32(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['bool_casted_to_i32'](),
+            Instance(TEST_BYTES).exports.bool_casted_to_i32(),
             1
         )
 
     def test_call_string(self):
         self.assertEqual(
-            Instance(TEST_BYTES).exports['string'](),
+            Instance(TEST_BYTES).exports.string(),
             1048576
         )
 

tests/memory_view.py

@@ -65,7 +65,7 @@ def test_set_out_of_range(self):
 
     def test_hello_world(self):
         instance = Instance(TEST_BYTES)
-        pointer = instance.exports['string']()
+        pointer = instance.exports.string()
         memory = instance.uint8_memory_view(pointer)
         nth = 0
         string = ''