Merge remote-tracking branch 'origin/main' into feat/uri-resolution-impl

Author: Niraj-Kamdar

packages/polywrap-client/polywrap_client/client.py

@@ -2,20 +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,
-    InterfaceImplementations,
     InvokerOptions,
     IUriResolutionContext,
     IUriResolver,
     TryResolveUriOptions,
+    Env,
     Uri,
     UriPackage,
     UriPackageOrWrapper,
@@ -48,24 +46,25 @@ def get_config(self):
     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
@@ -136,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,11 +1,11 @@
 import pytest
 from pathlib import Path
-
-from polywrap_client import PolywrapClient
-from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env, UriWrapper
+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_client.client import PolywrapClientConfig
 from polywrap_wasm import WRAP_MANIFEST_PATH, WRAP_MODULE_PATH, IFileReader, WasmWrapper
 
 @pytest.fixture
@@ -51,10 +51,12 @@ 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=simple_wrap_manifest
+        manifest=manifest
     )
     uri_wrapper = UriWrapper(uri=Uri("ens/wrapper.eth"), wrapper=wrapper)
     resolver = StaticResolver.from_list([uri_wrapper]).unwrap()
@@ -83,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()}'
     )
@@ -100,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(
@@ -123,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(),
@@ -138,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

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 *

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

@@ -2,31 +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 GetFileOptions:
     path: str
@@ -40,16 +33,16 @@ 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
 

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]

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

@@ -7,6 +7,7 @@
 from polywrap_result import Result
 
 from .uri import Uri
+from .env import Env
 from .uri_resolution_context import IUriResolutionContext
 
 
@@ -26,7 +27,7 @@ class InvokeOptions:
     uri: Uri
     method: str
     args: Optional[Union[Dict[str, Any], bytes]] = field(default_factory=dict)
-    env: Optional[Dict[str, Any]] = None
+    env: Optional[Env] = None
     resolution_context: Optional[IUriResolutionContext] = None
 
 
@@ -55,7 +56,7 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
         pass
 
     @abstractmethod
-    def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
+    def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None]]:
         pass
 
 

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

@@ -6,5 +6,5 @@
 
 class IWasmPackage(IWrapPackage, ABC):
     @abstractmethod
-    async def get_wasm_module() -> Result[bytearray]:
+    async def get_wasm_module() -> Result[bytes]:
         pass

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

@@ -1,10 +1,10 @@
-from typing import List, Union
+from typing import List, Union, Dict, Any
 
 from ..types import Client, Env, Uri
 
 
 def get_env_from_uri_history(
     uri_history: List[Uri], client: Client
-) -> Union[Env, None]:
+) -> Union[Dict[str, Any], None]:
     for uri in uri_history:
         return client.get_env_by_uri(uri)