Merge branch 'main' into feat/plugins-support

Author: Niraj-Kamdar

packages/polywrap-client/polywrap_client/client.py

@@ -2,21 +2,18 @@
 
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import Any, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, Union, cast
 
 from polywrap_core import (
     Client,
     ClientConfig,
-    Env,
-    GetEnvsOptions,
     GetFileOptions,
     GetManifestOptions,
-    GetUriResolversOptions,
-    InterfaceImplementations,
     InvokerOptions,
     IUriResolutionContext,
     IUriResolver,
     TryResolveUriOptions,
+    Env,
     Uri,
     UriPackage,
     UriPackageOrWrapper,
@@ -46,29 +43,28 @@ 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, options: Optional[GetEnvsOptions] = None) -> List[Env]:
-        return self._config.envs
+    def get_envs(self) -> Dict[Uri, Env]:
+        envs: Dict[Uri, Env] = self._config.envs
+        return envs
 
-    def get_interfaces(self) -> List[InterfaceImplementations]:
-        return self._config.interfaces
+    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[List[Uri]]:
-        if interface_implementations := next(
-            filter(lambda x: x.interface == uri, self._config.interfaces), None
-        ):
-            return Ok(interface_implementations.implementations)
+    def get_implementations(self, uri: Uri) -> Result[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}")
 
     def get_env_by_uri(
-        self, uri: Uri, options: Optional[GetEnvsOptions] = None
+        self, uri: Uri
     ) -> Union[Env, None]:
-        return next(filter(lambda env: env.uri == uri, self.get_envs()), None)
+        return self._config.envs.get(uri)
 
     async def get_file(
         self, uri: Uri, options: GetFileOptions
@@ -99,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(
@@ -139,9 +135,7 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
         if wrapper_result.is_err():
             return cast(Err, wrapper_result)
         wrapper = wrapper_result.unwrap()
-
-        env = self.get_env_by_uri(options.uri)
-        options.env = options.env or (env.env if env else None)
+        options.env = options.env or self.get_env_by_uri(options.uri)
 
         result = await wrapper.invoke(options, invoker=self)
         if result.is_err():

packages/polywrap-client/tests/test_client.py

@@ -1,13 +1,44 @@
+import pytest
 from pathlib import Path
-
-from polywrap_client import PolywrapClient
-from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env
-from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader
-
-from polywrap_client.client import PolywrapClientConfig
-
-
-async def test_invoke():
+import pytest
+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(
@@ -31,7 +85,7 @@ async def test_subinvoke():
         },
     )
 
-    client = PolywrapClient(config=PolywrapClientConfig(envs=[], resolver=uri_resolver))
+    client = PolywrapClient(config=PolywrapClientConfig(resolver=uri_resolver))
     uri = Uri(
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-subinvoke", "invoke").absolute()}'
     )
@@ -48,19 +102,15 @@ async def test_interface_implementation():
         redirects={},
     )
 
+    interface_uri = Uri("ens/interface.eth")
     impl_uri = Uri(
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-interface", "implementation").absolute()}'
     )
 
     client = PolywrapClient(
         config=PolywrapClientConfig(
-            envs=[],
             resolver=uri_resolver,
-            interfaces=[
-                InterfaceImplementations(
-                    interface=Uri("ens/interface.eth"), implementations=[impl_uri]
-                )
-            ],
+            interfaces= {interface_uri : [impl_uri]}
         )
     )
     uri = Uri(
@@ -71,10 +121,26 @@ async def test_interface_implementation():
         uri=uri, method="moduleMethod", args=args, encode_result=False
     )
     result = await client.invoke(options)
-
+    assert client.get_implementations(interface_uri) == Ok([impl_uri])
     assert result.unwrap() == {"str": "hello", "uint8": 2}
 
 
+def test_get_env_by_uri():
+    uri_resolver = BaseUriResolver(
+        file_reader=SimpleFileReader(),
+        redirects={},
+    )
+    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "simple-env").absolute()}')
+    env = {"externalArray": [1, 2, 3], "externalString": "hello"}
+
+    client = PolywrapClient(
+        config=PolywrapClientConfig(
+            envs={uri: env},
+            resolver=uri_resolver,
+        )
+    )
+    assert client.get_env_by_uri(uri) == env
+
 async def test_env():
     uri_resolver = BaseUriResolver(
         file_reader=SimpleFileReader(),
@@ -86,13 +152,14 @@ async def test_env():
 
     client = PolywrapClient(
         config=PolywrapClientConfig(
-            envs=[Env(uri=uri, env=env)],
+            envs={uri: env},
             resolver=uri_resolver,
         )
     )
     options = InvokerOptions(
-        uri=uri, method="externalEnvMethod", args={}, encode_result=False
+        uri=uri, method="externalEnvMethod", args={}, encode_result=False, 
     )
+
     result = await client.invoke(options)
 
-    assert result.unwrap() == env
+    assert result.unwrap() == env

packages/polywrap-client/tests/test_sha3.py

@@ -19,7 +19,6 @@ async def test_invoke_sha3_512():
     result = await client.invoke(options)
     s = hashlib.sha512()
     s.update(b"hello polywrap!")
-    print(result)
     assert result.result == s.digest()
 
 @pytest.mark.skip(reason="can't invoke sha3 wrapper due to an error related to wasmtime")
@@ -90,7 +89,6 @@ async def test_invoke_hex_keccak_256():
 async def test_invoke_buffer_keccak_256():
     options = InvokerOptions(uri=uri, method="buffer_keccak_256", args=args, encode_result=False)
     result = await client.invoke(options)
-    print(result)
     # TODO:  Not sure exactly what this function `buffer_keccak_256` is doing in order to assert it properly
     assert result.result == False
 

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

@@ -1,5 +1,4 @@
 from .client import *
-from .env import *
 from .file_reader import *
 from .invoke import *
 from .uri import *
@@ -10,6 +9,7 @@
 from .uri_resolver import *
 from .uri_resolver_handler import *
 from .uri_wrapper import *
+from .wrap_package import *
 from .wasm_package import *
 from .wrap_package import *
 from .wrapper import *

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

@@ -2,36 +2,24 @@
 
 from abc import abstractmethod
 from dataclasses import dataclass, field
-from typing import List, Optional, Union
+from typing import List, Optional, Union, Dict
 
 from polywrap_manifest import AnyWrapManifest, DeserializeManifestOptions
 from polywrap_result import Result
 
-from .env import Env
-from .interface_implementation import InterfaceImplementations
 from .invoke import Invoker
 from .uri import Uri
+from .env import Env
 from .uri_resolver import IUriResolver
 from .uri_resolver_handler import UriResolverHandler
 
-
 @dataclass(slots=True, kw_only=True)
 class ClientConfig:
-    envs: List[Env] = field(default_factory=list)
-    interfaces: List[InterfaceImplementations] = field(default_factory=list)
+    envs: Dict[Uri, Env] = field(default_factory=dict) 
+    interfaces: Dict[Uri, List[Uri]] = field(default_factory=dict)
     resolver: IUriResolver
 
 
-@dataclass(slots=True, kw_only=True)
-class GetEnvsOptions:
-    pass
-
-
-@dataclass(slots=True, kw_only=True)
-class GetUriResolversOptions:
-    pass
-
-
 @dataclass(slots=True, kw_only=True)
 class GetFileOptions:
     path: str
@@ -45,23 +33,21 @@ class GetManifestOptions(DeserializeManifestOptions):
 
 class Client(Invoker, UriResolverHandler):
     @abstractmethod
-    def get_interfaces(self) -> List[InterfaceImplementations]:
+    def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         pass
 
     @abstractmethod
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> List[Env]:
+    def get_envs(self) -> Dict[Uri, Env]:
         pass
 
     @abstractmethod
     def get_env_by_uri(
-        self, uri: Uri, options: Optional[GetEnvsOptions] = None
+        self, uri: Uri
     ) -> Union[Env, None]:
         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/env.py

@@ -1,20 +1,3 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
 from typing import Any, Dict
 
-from .uri import Uri
-
-
-@dataclass(slots=True, kw_only=True)
-class Env:
-    """
-    this type can be used to set env for a wrapper in the client
-
-    Args:
-        uri: Uri of wrapper
-        env: env variables used by the module
-    """
-
-    uri: Uri
-    env: Dict[str, Any] = field(default_factory=dict)
+Env = Dict[str, Any]