refactor: polywrap-wasm package (#183)

Author: Niraj-Kamdar

packages/polywrap-wasm/polywrap_wasm/__init__.py

@@ -1,8 +1,5 @@
 """This module contains the runtime for executing Wasm wrappers."""
-from .buffer import *
 from .errors import *
-from .exports import *
-from .imports import *
 from .inmemory_file_reader import *
 from .wasm_package import *
 from .wasm_wrapper import *

packages/polywrap-wasm/polywrap_wasm/constants.py

@@ -1,3 +1,5 @@
 """This module contains the constants used by polywrap-wasm package."""
 WRAP_MANIFEST_PATH = "wrap.info"
 WRAP_MODULE_PATH = "wrap.wasm"
+
+__all__ = ["WRAP_MANIFEST_PATH", "WRAP_MODULE_PATH"]

packages/polywrap-wasm/polywrap_wasm/errors.py

@@ -12,3 +12,10 @@ class WasmExportNotFoundError(WasmError):
 
 class WasmMemoryError(WasmError):
     """Raises when the Wasm memory is not found."""
+
+
+__all__ = [
+    "WasmError",
+    "WasmExportNotFoundError",
+    "WasmMemoryError",
+]

packages/polywrap-wasm/polywrap_wasm/imports/get_implementations.py

@@ -24,6 +24,11 @@ def wrap_get_implementations(self, uri_ptr: int, uri_len: int) -> bool:
                 uri_len,
             )
         )
+        if not self.invoker:
+            raise WrapAbortError(
+                invoke_options=self.state.invoke_options,
+                message="Expected invoker to be defined got None",
+            )
         try:
             maybe_implementations = self.invoker.get_implementations(uri=uri)
             implementations: List[str] = (
@@ -35,8 +40,8 @@ def wrap_get_implementations(self, uri_ptr: int, uri_len: int) -> bool:
             return len(implementations) > 0
         except Exception as err:
             raise WrapAbortError(
-                self.state.invoke_options,
-                f"failed calling invoker.get_implementations({repr(uri)})",
+                invoke_options=self.state.invoke_options,
+                message=f"failed calling invoker.get_implementations({repr(uri)})",
             ) from err
 
     def wrap_get_implementations_result_len(self) -> int:
@@ -59,6 +64,12 @@ def wrap_get_implementations_result(self, ptr: int) -> None:
         self.write_bytes(ptr, result)
 
     def _get_get_implementations_result(self, export_name: str):
+        if not self.invoker:
+            raise WrapAbortError(
+                invoke_options=self.state.invoke_options,
+                message="Expected invoker to be defined got None",
+            )
+
         if not self.state.get_implementations_result:
             raise WrapAbortError(
                 self.state.invoke_options,

packages/polywrap-wasm/polywrap_wasm/imports/subinvoke.py

@@ -1,15 +1,10 @@
 """This module contains the subinvoke imports for the Wasm module."""
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-
-from polywrap_core import InvokerOptions, Uri, WrapAbortError
+from polywrap_core import Uri, WrapAbortError
 from polywrap_msgpack import msgpack_encode
 
 from ..types import InvokeResult
 from .types import BaseWrapImports
 
-pool = ThreadPoolExecutor()
-
 
 class WrapSubinvokeImports(BaseWrapImports):
     """Defines the subinvoke family of imports for the Wasm module."""
@@ -42,18 +37,19 @@ def wrap_subinvoke(
         method = self._get_subinvoke_method(method_ptr, method_len)
         args = self._get_subinvoke_args(args_ptr, args_len)
 
+        if not self.invoker:
+            raise WrapAbortError(
+                invoke_options=self.state.invoke_options,
+                message="Expected invoker to be defined got None",
+            )
+
         try:
-            result = pool.submit(
-                asyncio.run,
-                self.invoker.invoke(
-                    InvokerOptions(
-                        uri=uri,
-                        method=method,
-                        args=args,
-                        encode_result=True,
-                    )
-                ),
-            ).result()
+            result = self.invoker.invoke(
+                uri=uri,
+                method=method,
+                args=args,
+                encode_result=True,
+            )
             if isinstance(result, bytes):
                 self.state.subinvoke_result = InvokeResult(result=result)
                 return True

packages/polywrap-wasm/polywrap_wasm/imports/types/base_wrap_imports.py

@@ -2,8 +2,9 @@
 from __future__ import annotations
 
 from abc import ABC
+from typing import Optional
 
-from polywrap_core import Invoker, UriPackageOrWrapper
+from polywrap_core import Invoker
 from wasmtime import Memory, Store
 
 from ...buffer import read_bytes, read_string, write_bytes, write_string
@@ -16,7 +17,7 @@ class BaseWrapImports(ABC):
     memory: Memory
     store: Store
     state: State
-    invoker: Invoker[UriPackageOrWrapper]
+    invoker: Optional[Invoker]
 
     def read_string(self, ptr: int, length: int) -> str:
         """Read a UTF-8 encoded string from the memory buffer."""

packages/polywrap-wasm/polywrap_wasm/imports/utils/__init__.py

@@ -3,7 +3,9 @@
 # pylint: disable=too-many-ancestors
 from __future__ import annotations
 
-from polywrap_core import Invoker, UriPackageOrWrapper
+from typing import Optional
+
+from polywrap_core import Invoker
 from wasmtime import Memory, Store
 
 from ..types.state import State
@@ -39,7 +41,7 @@ def __init__(
         memory: Memory,
         store: Store,
         state: State,
-        invoker: Invoker[UriPackageOrWrapper],
+        invoker: Optional[Invoker],
     ) -> None:
         """Initialize the WrapImports instance.
 

packages/polywrap-wasm/polywrap_wasm/imports/utils/unsync_invoke.py

@@ -31,7 +31,7 @@ def __init__(
         self._wasm_manifest = wasm_manifest
         self._base_file_reader = base_file_reader
 
-    async def read_file(self, file_path: str) -> bytes:
+    def read_file(self, file_path: str) -> bytes:
         """Read a file from memory.
 
         Args:
@@ -44,4 +44,7 @@ async def read_file(self, file_path: str) -> bytes:
             return self._wasm_module
         if file_path == WRAP_MANIFEST_PATH and self._wasm_manifest:
             return self._wasm_manifest
-        return await self._base_file_reader.read_file(file_path=file_path)
+        return self._base_file_reader.read_file(file_path=file_path)
+
+
+__all__ = ["InMemoryFileReader"]