refactor polywrap-client and fix tests

Author: Niraj-Kamdar

packages/polywrap-client/poetry.lock

@@ -13,19 +13,17 @@
     GetManifestOptions,
     InvokerOptions,
     IUriResolutionContext,
-    IUriResolver,
-    IWrapPackage,
+    UriPackage,
+    UriResolver,
+    UriWrapper,
     TryResolveUriOptions,
     Uri,
     UriPackageOrWrapper,
-    UriResolutionContext,
     Wrapper,
-    build_clean_uri_history,
 )
 from polywrap_manifest import AnyWrapManifest
 from polywrap_msgpack import msgpack_decode, msgpack_encode
-from polywrap_result import Err, Ok, Result
-from polywrap_uri_resolvers import FsUriResolver, SimpleFileReader
+from polywrap_uri_resolvers import UriResolutionContext, build_clean_uri_history
 
 
 @dataclass(slots=True, kw_only=True)
@@ -36,16 +34,13 @@ class PolywrapClientConfig(ClientConfig):
 class PolywrapClient(Client):
     _config: PolywrapClientConfig
 
-    def __init__(self, config: Optional[PolywrapClientConfig] = None):
-        # TODO: this is naive solution need to use polywrap-client-config-builder once we have it
-        self._config = config or PolywrapClientConfig(
-            resolver=FsUriResolver(file_reader=SimpleFileReader())
-        )
+    def __init__(self, config: PolywrapClientConfig):
+        self._config = config
 
     def get_config(self):
         return self._config
 
-    def get_uri_resolver(self) -> IUriResolver:
+    def get_uri_resolver(self) -> UriResolver:
         return self._config.resolver
 
     def get_envs(self) -> Dict[Uri, Env]:
@@ -56,100 +51,81 @@ def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         interfaces: Dict[Uri, List[Uri]] = self._config.interfaces
         return interfaces
 
-    def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None]]:
+    def get_implementations(self, uri: Uri) -> Union[List[Uri], None]:
         interfaces: Dict[Uri, List[Uri]] = self.get_interfaces()
-        if interfaces.get(uri):
-            return Ok(interfaces.get(uri))
-        else:
-            return Err.from_str(f"Unable to find implementations for uri: {uri}")
+        return interfaces.get(uri)
 
     def get_env_by_uri(self, uri: Uri) -> Union[Env, None]:
         return self._config.envs.get(uri)
 
-    async def get_file(
-        self, uri: Uri, options: GetFileOptions
-    ) -> Result[Union[bytes, str]]:
-        loaded_wrapper = (await self.load_wrapper(uri)).unwrap()
+    async def get_file(self, uri: Uri, options: GetFileOptions) -> Union[bytes, str]:
+        loaded_wrapper = await self.load_wrapper(uri)
         return await loaded_wrapper.get_file(options)
 
     async def get_manifest(
         self, uri: Uri, options: Optional[GetManifestOptions] = None
-    ) -> Result[AnyWrapManifest]:
-        loaded_wrapper = (await self.load_wrapper(uri)).unwrap()
+    ) -> AnyWrapManifest:
+        loaded_wrapper = await self.load_wrapper(uri)
         return loaded_wrapper.get_manifest()
 
     async def try_resolve_uri(
-        self, options: TryResolveUriOptions
-    ) -> Result[UriPackageOrWrapper]:
+        self, options: TryResolveUriOptions[UriPackageOrWrapper]
+    ) -> UriPackageOrWrapper:
         uri = options.uri
         uri_resolver = self._config.resolver
         resolution_context = options.resolution_context or UriResolutionContext()
 
         return await uri_resolver.try_resolve_uri(uri, self, resolution_context)
 
     async def load_wrapper(
-        self, uri: Uri, resolution_context: Optional[IUriResolutionContext] = None
-    ) -> Result[Wrapper]:
+        self,
+        uri: Uri,
+        resolution_context: Optional[IUriResolutionContext[UriPackageOrWrapper]] = None,
+    ) -> Wrapper[UriPackageOrWrapper]:
         resolution_context = resolution_context or UriResolutionContext()
 
-        result = await self.try_resolve_uri(
+        uri_package_or_wrapper = await self.try_resolve_uri(
             TryResolveUriOptions(uri=uri, resolution_context=resolution_context)
         )
-        if result.is_err():
-            return cast(Err, result)
-        if result.is_ok() and result.ok() is None:
-            return Err.from_str(
-                dedent(
-                    f"""
-                    Error resolving URI "{uri.uri}"
-                    Resolution Stack: {json.dumps(build_clean_uri_history(resolution_context.get_history()), indent=2)}
-                    """
-                )
-            )
 
-        uri_package_or_wrapper = result.unwrap()
-
-        if isinstance(uri_package_or_wrapper, Uri):
-            return Err.from_str(
-                dedent(
-                    f"""
-                    Error resolving URI "{uri.uri}"
-                    URI not found
-                    Resolution Stack: {json.dumps(build_clean_uri_history(resolution_context.get_history()), indent=2)}
-                    """
-                )
+        if isinstance(uri_package_or_wrapper, UriPackage):
+            return await cast(
+                UriPackage[UriPackageOrWrapper], uri_package_or_wrapper
+            ).package.create_wrapper()
+
+        if isinstance(uri_package_or_wrapper, UriWrapper):
+            return cast(UriWrapper[UriPackageOrWrapper], uri_package_or_wrapper).wrapper
+
+        raise RuntimeError(
+            dedent(
+                f"""
+                Error resolving URI "{uri.uri}"
+                URI not found
+                Resolution Stack: {json.dumps(build_clean_uri_history(resolution_context.get_history()), indent=2)}
+                """
             )
+        )
 
-        if isinstance(uri_package_or_wrapper, IWrapPackage):
-            return await uri_package_or_wrapper.create_wrapper()
-
-        return Ok(uri_package_or_wrapper)
 
-    async def invoke(self, options: InvokerOptions) -> Result[Any]:
+    async def invoke(self, options: InvokerOptions[UriPackageOrWrapper]) -> Any:
         resolution_context = options.resolution_context or UriResolutionContext()
-        wrapper_result = await self.load_wrapper(
+        wrapper = await self.load_wrapper(
             options.uri, resolution_context=resolution_context
         )
-        if wrapper_result.is_err():
-            return cast(Err, wrapper_result)
-        wrapper = wrapper_result.unwrap()
         options.env = options.env or self.get_env_by_uri(options.uri)
 
-        result = await wrapper.invoke(options, invoker=self)
-        if result.is_err():
-            return cast(Err, result)
-        invocable_result = result.unwrap()
+        invocable_result = await wrapper.invoke(options, invoker=self)
 
         if options.encode_result and not invocable_result.encoded:
             encoded = msgpack_encode(invocable_result.result)
-            return Ok(encoded)
+            return encoded
 
         if (
             not options.encode_result
             and invocable_result.encoded
             and isinstance(invocable_result.result, (bytes, bytearray))
         ):
             decoded: Any = msgpack_decode(invocable_result.result)
-            return Ok(decoded)
+            return decoded
 
-        return Ok(invocable_result.result)
+        return invocable_result.result

packages/polywrap-client/polywrap_client/client.py

@@ -11,16 +11,10 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.10"
-wasmtime = "^1.0.1"
-unsync = "^1.4.0"
 polywrap-core = { path = "../polywrap-core", develop = true }
 polywrap-msgpack = { path = "../polywrap-msgpack", develop = true }
 polywrap-manifest = { path = "../polywrap-manifest", develop = true }
-polywrap-result = { path = "../polywrap-result", develop = true }
 polywrap-uri-resolvers = { path = "../polywrap-uri-resolvers", develop = true }
-result = "^0.8.0"
-pysha3 = "^1.0.2"
-pycryptodome = "^3.14.1"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.1.2"
@@ -34,6 +28,10 @@ isort = "^5.10.1"
 pyright = "^1.1.275"
 pydocstyle = "^6.1.1"
 
+[tool.poetry.group.test.dependencies]
+pysha3 = "^1.0.2"
+pycryptodome = "^3.17"
+
 [tool.bandit]
 exclude_dirs = ["tests"]
 

packages/polywrap-client/polywrap_client/py.typed

@@ -0,0 +1,39 @@
+
+from pathlib import Path
+from polywrap_core import FileReader
+from polywrap_uri_resolvers import WRAP_MANIFEST_PATH, WRAP_MODULE_PATH, FsUriResolver, SimpleFileReader
+from polywrap_client import PolywrapClient, PolywrapClientConfig
+from pytest import fixture
+
+
+@fixture
+def client():
+    config = PolywrapClientConfig(
+            resolver=FsUriResolver(file_reader=SimpleFileReader())
+        )
+    return PolywrapClient(config)
+
+@fixture
+def simple_wrap_module():
+    wrap_path = Path(__file__).parent / "cases" / "simple-invoke" / "wrap.wasm"
+    with open(wrap_path, "rb") as f:
+        yield f.read()
+
+
+@fixture
+def simple_wrap_manifest():
+    wrap_path = Path(__file__).parent / "cases" / "simple-invoke" / "wrap.info"
+    with open(wrap_path, "rb") as f:
+        yield f.read()
+
+@fixture
+def simple_file_reader(simple_wrap_module: bytes, simple_wrap_manifest: bytes):
+    class SimpleFileReader(FileReader):
+        async def read_file(self, file_path: str) -> bytes:
+            if file_path == WRAP_MODULE_PATH:
+                return simple_wrap_module
+            if file_path == WRAP_MANIFEST_PATH:
+                return simple_wrap_manifest
+            raise FileNotFoundError(f"FileNotFound: {file_path}")
+
+    yield SimpleFileReader()

packages/polywrap-client/pyproject.toml

@@ -3,54 +3,69 @@
 
 from pathlib import Path
 from polywrap_client import PolywrapClient
-from polywrap_core import Uri, InvokerOptions
+from polywrap_core import Uri, InvokerOptions, UriPackageOrWrapper
 
 
-async def test_invoke_bignumber_1arg_and_1prop():
-    client = PolywrapClient()
-    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}')
+async def test_invoke_bignumber_1arg_and_1prop(client: PolywrapClient):
+    uri = Uri.from_str(
+        f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}'
+    )
     args = {
         "arg1": "123",  # The base number
         "obj": {
             "prop1": "1000",  # multiply the base number by this factor
         },
     }
-    options = InvokerOptions(uri=uri, method="method", args=args, encode_result=False)
+    options: InvokerOptions[UriPackageOrWrapper] = InvokerOptions(
+        uri=uri, method="method", args=args, encode_result=False
+    )
     result = await client.invoke(options)
-    assert result.unwrap() == "123000"
+    assert result == "123000"
 
 
-async def test_invoke_bignumber_with_1arg_and_2props():
-    client = PolywrapClient()
-    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}')
+async def test_invoke_bignumber_with_1arg_and_2props(client: PolywrapClient):
+    uri = Uri.from_str(
+        f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}'
+    )
     args = {"arg1": "123123", "obj": {"prop1": "1000", "prop2": "4"}}
-    options = InvokerOptions(uri=uri, method="method", args=args, encode_result=False)
+    options: InvokerOptions[UriPackageOrWrapper] = InvokerOptions(
+        uri=uri, method="method", args=args, encode_result=False
+    )
     result = await client.invoke(options)
-    assert result.unwrap() == str(123123 * 1000 * 4)
+    assert result == str(123123 * 1000 * 4)
 
 
-async def test_invoke_bignumber_with_2args_and_1prop():
-    client = PolywrapClient()
-    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}')
+async def test_invoke_bignumber_with_2args_and_1prop(client: PolywrapClient):
+    uri = Uri.from_str(
+        f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}'
+    )
     args = {"arg1": "123123", "obj": {"prop1": "1000", "prop2": "444"}}
-    options = InvokerOptions(uri=uri, method="method", args=args, encode_result=False)
+    options: InvokerOptions[UriPackageOrWrapper] = InvokerOptions(
+        uri=uri, method="method", args=args, encode_result=False
+    )
     result = await client.invoke(options)
-    assert result.unwrap() == str(123123 * 1000 * 444)
+    assert result == str(123123 * 1000 * 444)
 
 
-async def test_invoke_bignumber_with_2args_and_2props():
-    client = PolywrapClient()
-    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}')
+async def test_invoke_bignumber_with_2args_and_2props(client: PolywrapClient):
+    uri = Uri.from_str(
+        f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}'
+    )
     args = {"arg1": "123123", "arg2": "555", "obj": {"prop1": "1000", "prop2": "4"}}
-    options = InvokerOptions(uri=uri, method="method", args=args, encode_result=False)
+    options: InvokerOptions[UriPackageOrWrapper] = InvokerOptions(
+        uri=uri, method="method", args=args, encode_result=False
+    )
     result = await client.invoke(options)
-    assert result.unwrap() == str(123123 * 555 * 1000 * 4)
+    assert result == str(123123 * 555 * 1000 * 4)
 
 
-async def test_invoke_bignumber_with_2args_and_2props_floats():
-    client = PolywrapClient()
-    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}')
+async def test_invoke_bignumber_with_2args_and_2props_floats(client: PolywrapClient):
+    uri = Uri.from_str(
+        f'fs/{Path(__file__).parent.joinpath("cases", "big-number").absolute()}'
+    )
     args = {"arg1": "123.123", "arg2": "55.5", "obj": {"prop1": "10.001", "prop2": "4"}}
-    options = InvokerOptions(uri=uri, method="method", args=args, encode_result=False)
+    options: InvokerOptions[UriPackageOrWrapper] = InvokerOptions(
+        uri=uri, method="method", args=args, encode_result=False
+    )
     result = await client.invoke(options)
-    assert result.unwrap() == str(123.123 * 55.5 * 10.001 * 4)
+    assert result == str(123.123 * 55.5 * 10.001 * 4)