Merge pull request #581 from wasmerio/wasi-imports

WASI imports should return a dict

Author: syrusakbary

packages/api/src/import_object.rs

@@ -163,6 +163,20 @@ impl ImportObject {
     }
 }
 
+impl ImportObject {
+    /// Gets an `ImportObject` from a Python dictionary.
+    pub(crate) fn from_pydict(dict: &PyDict) -> Result<Self, PyErr> {
+        let mut io = ImportObject::new();
+        for (namespace_name, namespace_dict) in dict.into_iter() {
+            let namespace_name = namespace_name.to_string();
+            let namespace_dict = namespace_dict
+                .downcast::<PyDict>()?;
+            io.register(&namespace_name, namespace_dict)?;
+        }
+        Ok(io)
+    }
+}
+
 #[pymethods]
 impl ImportObject {
     #[new]
@@ -186,6 +200,43 @@ impl ImportObject {
         self.inner.contains_namespace(namespace_name)
     }
 
+    /// Gets a Python dictionary from an `ImportObject`.
+    #[pyo3(text_signature = "($self)")]
+    pub(crate) fn to_dict<'py>(&'py self) -> Result<PyObject, PyErr> {
+        let gil_guard = Python::acquire_gil();
+        let py = gil_guard.python();
+
+        let dict = PyDict::new(py);
+        for (namespace, name, export) in self.inner.externs_vec() {
+            let elem = match export {
+                wasmer::Extern::Function(function) => {
+                    Py::new(py, Function::raw_new(function.clone()))?.to_object(py)
+                }
+                wasmer::Extern::Global(global) => {
+                    Py::new(py, Global::raw_new(global.clone()))?.to_object(py)
+                }
+                wasmer::Extern::Memory(memory) => {
+                    Py::new(py, Memory::raw_new(memory.clone()))?.to_object(py)
+                }
+                wasmer::Extern::Table(table) => {
+                    Py::new(py, Table::raw_new(table.clone()))?.to_object(py)
+                }
+            };
+            let namespace_dict = match dict.get_item(&namespace) {
+                Some(namespace_dict) => {
+                    namespace_dict
+                },
+                None => {
+                    let namespace_dict = PyDict::new(py);
+                    dict.set_item(&namespace, namespace_dict)?;
+                    namespace_dict
+                }
+            };
+            namespace_dict.set_item(&name, elem)?;
+        }
+        Ok(dict.to_object(py))
+    }
+
     /// Registers a set of `Function`, `Memory`, `Global` or `Table`
     /// to a particular namespace.
     ///

packages/api/src/instance.rs

@@ -113,15 +113,8 @@ impl Instance {
                 Ok(io) => wasmer::Instance::new(&module, io.borrow().inner()),
                 Err(_e) => match import_object.downcast::<PyDict>() {
                     Ok(dict) => {
-                        let mut io = ImportObject::new();
-                        for (namespace_name, namespace_dict) in dict.into_iter() {
-                            let namespace_name = namespace_name.to_string();
-                            let namespace_dict = namespace_dict
-                                .downcast::<PyDict>()
-                                .map_err(|e| InstanceError::PyErr(e.into()))?;
-                            io.register(&namespace_name, namespace_dict)
-                                .map_err(|e| InstanceError::PyErr(e.into()))?;
-                        }
+                        let io = ImportObject::from_pydict(dict)
+                            .map_err(|e| InstanceError::PyErr(e.into()))?;
                         wasmer::Instance::new(&module, io.borrow().inner())
                     }
                     Err(e) => {

packages/api/src/wasi.rs

@@ -474,6 +474,27 @@ impl Environment {
 
         ImportObject::raw_new(import_object)
     }
+
+    /// Create a dictionary of import with an existing
+    /// `Environment`. The import object will be different according
+    /// to the WASI version.
+    ///
+    /// Use the `Version` enum to use a specific WASI version, or use
+    /// `get_version` to read the WASI version from a `wasmer.Module`.
+    ///
+    /// ## Example
+    ///
+    /// ```py
+    /// from wasmer import wasi, Store
+    ///
+    /// store = Store()
+    /// wasi_env = wasi.StateBuilder('test-program').argument('--foo').finalize()
+    /// imports = wasi_env.generate_imports(store, wasi.Version.SNAPSHOT1)
+    /// ```
+    //#[pyo3(text_signature = "($self, store, wasi_version)")]
+    fn generate_imports(&self, store: &Store, wasi_version: Version) -> PyResult<PyObject> {
+        self.generate_import_object(store, wasi_version).to_dict()
+    }
 }
 
 pub fn get_version(module: &Module, strict: bool) -> Option<Version> {

tests/test_wasi.py

@@ -33,7 +33,55 @@ def test_wasi_env():
 def test_wasi_import_object():
     env = wasi.StateBuilder("foo").finalize()
 
-    assert isinstance(env.generate_import_object(Store(), wasi.Version.LATEST), ImportObject)
+    import_object = env.generate_import_object(Store(), wasi.Version.LATEST)
+    assert isinstance(import_object, dict)
+    assert sorted(import_object['wasi_snapshot_preview1'].keys()) == [
+        'args_get',
+        'args_sizes_get',
+        'clock_res_get',
+        'clock_time_get',
+        'environ_get',
+        'environ_sizes_get',
+        'fd_advise',
+        'fd_allocate',
+        'fd_close',
+        'fd_datasync',
+        'fd_fdstat_get',
+        'fd_fdstat_set_flags',
+        'fd_fdstat_set_rights',
+        'fd_filestat_get',
+        'fd_filestat_set_size',
+        'fd_filestat_set_times',
+        'fd_pread',
+        'fd_prestat_dir_name',
+        'fd_prestat_get',
+        'fd_pwrite',
+        'fd_read',
+        'fd_readdir',
+        'fd_renumber',
+        'fd_seek',
+        'fd_sync',
+        'fd_tell',
+        'fd_write',
+        'path_create_directory',
+        'path_filestat_get',
+        'path_filestat_set_times',
+        'path_link',
+        'path_open',
+        'path_readlink',
+        'path_remove_directory',
+        'path_rename',
+        'path_symlink',
+        'path_unlink_file',
+        'poll_oneoff',
+        'proc_exit',
+        'proc_raise',
+        'random_get',
+        'sched_yield',
+        'sock_recv',
+        'sock_send',
+        'sock_shutdown'
+    ]
 
 def test_wasi_env_memory():
     store = Store()