Feat: Static Resolver implementation

packages/polywrap-client/polywrap_client/client.py

@@ -9,7 +9,6 @@
     ClientConfig,
     GetFileOptions,
     GetManifestOptions,
-    GetUriResolversOptions,
     InvokerOptions,
     IUriResolutionContext,
     IUriResolver,
@@ -44,9 +43,7 @@ def __init__(self, config: Optional[PolywrapClientConfig] = None):
     def get_config(self):
         return self._config
 
-    def get_uri_resolver(
-        self, options: Optional[GetUriResolversOptions] = None
-    ) -> IUriResolver:
+    def get_uri_resolver(self) -> IUriResolver:
         return self._config.resolver
 
     def get_envs(self) -> Dict[Uri, Env]:
@@ -98,9 +95,9 @@ async def load_wrapper(
         result = await self.try_resolve_uri(
             TryResolveUriOptions(uri=uri, resolution_context=resolution_context)
         )
-        if result.is_err() == True:
+        if result.is_err():
             return cast(Err, result)
-        if result.is_ok() == True and result.ok is None:
+        if result.is_ok() and result.ok is None:
             # FIXME: add resolution stack
             return Err.from_str(
                 dedent(

packages/polywrap-client/tests/test_client.py

@@ -1,13 +1,44 @@
+import pytest
 from pathlib import Path
 import pytest
-from polywrap_client import PolywrapClient
-from polywrap_core import Uri, InvokerOptions
-from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader
-from polywrap_result import Ok
-from polywrap_client.client import PolywrapClientConfig
-
-
-async def test_invoke():
+from polywrap_client import PolywrapClient, PolywrapClientConfig
+from polywrap_manifest import deserialize_wrap_manifest
+from polywrap_core import Uri, InvokerOptions, UriWrapper
+from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader, StaticResolver
+from polywrap_result import Result, Ok, Err
+from polywrap_wasm import WRAP_MANIFEST_PATH, WRAP_MODULE_PATH, IFileReader, WasmWrapper
+
+@pytest.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()
+
+
+@pytest.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()
+
+@pytest.fixture
+def simple_file_reader(simple_wrap_module: bytes, simple_wrap_manifest: bytes):
+    class FileReader(IFileReader):
+        async def read_file(self, file_path: str) -> Result[bytes]:
+            if file_path == WRAP_MODULE_PATH:
+                return Ok(simple_wrap_module)
+            if file_path == WRAP_MANIFEST_PATH:
+                return Ok(simple_wrap_manifest)
+            return Err.from_str(f"FileNotFound: {file_path}")
+
+    yield FileReader()
+
+@pytest.mark.asyncio
+async def test_invoke(
+    simple_file_reader: IFileReader,
+    simple_wrap_module: bytes,
+    simple_wrap_manifest: bytes
+):
     client = PolywrapClient()
     uri = Uri(
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-invoke").absolute()}'
@@ -20,6 +51,29 @@ async def test_invoke():
 
     assert result.unwrap() == args["arg"]
 
+    manifest = deserialize_wrap_manifest(simple_wrap_manifest).unwrap()
+
+    wrapper = WasmWrapper(
+        file_reader=simple_file_reader, 
+        wasm_module=simple_wrap_module, 
+        manifest=manifest
+    )
+    uri_wrapper = UriWrapper(uri=Uri("ens/wrapper.eth"), wrapper=wrapper)
+    resolver = StaticResolver.from_list([uri_wrapper]).unwrap()
+
+    config = PolywrapClientConfig(resolver=resolver)
+    client = PolywrapClient(config=config)
+
+    args = {"arg": "hello polywrap"}
+    options = InvokerOptions(
+        uri=Uri("ens/wrapper.eth"), 
+        method="simpleMethod", 
+        args=args, 
+        encode_result=False
+    )
+    result = await client.invoke(options)
+
+    assert result.unwrap() == args["arg"]
 
 async def test_subinvoke():
     uri_resolver = BaseUriResolver(
@@ -108,4 +162,4 @@ async def test_env():
 
     result = await client.invoke(options)
 
-    assert result.unwrap() == env
+    assert result.unwrap() == env

packages/polywrap-core/polywrap_core/types/__init__.py

@@ -9,5 +9,6 @@
 from .uri_resolver import *
 from .uri_resolver_handler import *
 from .uri_wrapper import *
+from .wrap_package import *
 from .wasm_package import *
 from .wrapper import *

packages/polywrap-core/polywrap_core/types/client.py

@@ -20,11 +20,6 @@ class ClientConfig:
     resolver: IUriResolver
 
 
-@dataclass(slots=True, kw_only=True)
-class GetUriResolversOptions:
-    pass
-
-
 @dataclass(slots=True, kw_only=True)
 class GetFileOptions:
     path: str
@@ -52,9 +47,7 @@ def get_env_by_uri(
         pass
 
     @abstractmethod
-    def get_uri_resolver(
-        self, options: Optional[GetUriResolversOptions] = None
-    ) -> IUriResolver:
+    def get_uri_resolver(self) -> IUriResolver:
         pass
 
     @abstractmethod

packages/polywrap-core/polywrap_core/types/uri.py

@@ -2,6 +2,7 @@
 
 import re
 from dataclasses import dataclass
+from functools import total_ordering
 from typing import Any, List, Optional, Tuple, Union
 
 
@@ -14,6 +15,7 @@ class UriConfig:
     uri: str
 
 
+@total_ordering
 class Uri:
     """
     A Polywrap URI.

packages/polywrap-core/polywrap_core/types/uri_package.py

@@ -3,10 +3,10 @@
 from dataclasses import dataclass
 
 from .uri import Uri
-from .wasm_package import IWasmPackage
+from .wrap_package import IWrapPackage
 
 
 @dataclass(slots=True, kw_only=True)
 class UriPackage:
     uri: Uri
-    package: IWasmPackage
+    package: IWrapPackage

packages/polywrap-core/polywrap_core/types/uri_resolution_step.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from polywrap_result import Result
 
@@ -16,4 +16,4 @@ class IUriResolutionStep:
     source_uri: Uri
     result: Result["UriPackageOrWrapper"]
     description: Optional[str] = None
-    sub_history: Optional["IUriResolutionStep"] = None
+    sub_history: Optional[List["IUriResolutionStep"]] = None

packages/polywrap-core/polywrap_core/types/wasm_package.py

@@ -1,20 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import Optional
 
-from polywrap_manifest import AnyWrapManifest
 from polywrap_result import Result
+from .wrap_package import IWrapPackage
 
-from .client import GetManifestOptions
-from .wrapper import Wrapper
-
-
-class IWasmPackage(ABC):
-    @abstractmethod
-    async def create_wrapper(self) -> Result[Wrapper]:
-        pass
 
+class IWasmPackage(IWrapPackage, ABC):
     @abstractmethod
-    async def get_manifest(
-        self, options: Optional[GetManifestOptions] = None
-    ) -> Result[AnyWrapManifest]:
+    async def get_wasm_module() -> Result[bytes]:
         pass

packages/polywrap-core/polywrap_core/types/wrap_package.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from polywrap_manifest import AnyWrapManifest
+from polywrap_result import Result
+
+from .client import GetManifestOptions
+from .wrapper import Wrapper
+
+
+class IWrapPackage(ABC):
+    @abstractmethod
+    async def create_wrapper(self) -> Result[Wrapper]:
+        pass
+
+    @abstractmethod
+    async def get_manifest(
+        self, options: Optional[GetManifestOptions] = None
+    ) -> Result[AnyWrapManifest]:
+        pass

packages/polywrap-core/polywrap_core/uri_resolution/uri_resolution_result.py

@@ -4,7 +4,7 @@
 
 from ..types import (
     IUriResolutionStep,
-    IWasmPackage,
+    IWrapPackage,
     Uri,
     UriPackage,
     UriPackageOrWrapper,
@@ -20,7 +20,7 @@ class UriResolutionResult:
     @staticmethod
     def ok(
         uri: Uri,
-        package: Optional[IWasmPackage] = None,
+        package: Optional[IWrapPackage] = None,
         wrapper: Optional[Wrapper] = None,
     ) -> Result[UriPackageOrWrapper]:
         if wrapper:

packages/polywrap-msgpack/polywrap_msgpack/__init__.py

@@ -59,7 +59,7 @@ def sanitize(value: Any) -> Any:
         array: List[Any] = value
         return [sanitize(a) for a in array]
     if isinstance(value, tuple):
-        array: List[Any] = list(value)  # type: ignore
+        array: List[Any] = list(value)  # type: ignore partially unknown
         return sanitize(array)
     if isinstance(value, set):
         set_val: Set[Any] = value

packages/polywrap-uri-resolvers/__init__.py

@@ -1 +1 @@
-from .uri_resolvers import *
+from .polywrap_uri_resolvers import *