feat:implemented_add_envs, added tests for add_envs and set_envs together.

Author: rihp

packages/polywrap-client-config-builder/polywrap_client_config_builder/__init__.py

@@ -1,2 +1 @@
 from .client_config_builder import *
-from .client_config import *

packages/polywrap-client-config-builder/polywrap_client_config_builder/client_config.py

@@ -11,7 +11,7 @@ class ClientConfig():
     """
     envs: Dict[Uri, Dict[str, Any]]
     interfaces: Dict[Uri, List[Uri]]
-    resolver: IUriResolver
+    resolver: List[IUriResolver]
     wrappers: List[Uri]
 
 
@@ -23,7 +23,7 @@ class IClientConfigBuilder(ABC):
     """
 
     @abstractmethod
-    def build() -> ClientConfig:
+    def build(self) -> ClientConfig:
         """Returns a sanitized config object from the builder's config."""
         pass
 
@@ -32,15 +32,15 @@ def get_envs(self) -> Optional[Dict[Uri, Dict[str, Any]]]:
         pass
 
     @abstractmethod
-    def set_env(self, env: Dict[str, Any], uri: Uri):
+    def set_env(self, env: Dict[str, Any], uri: Uri)-> ClientConfig:
         pass
 
     @abstractmethod
-    def add_env(self, env: Dict[str, Any], uri: Uri):
+    def add_env(self, env: Dict[str, Any], uri: Uri) -> ClientConfig:
         pass
 
     @abstractmethod
-    def add_envs(self, envs: List[Env], uri: Uri):
+    def add_envs(self, envs: List[Env], uri: Uri) -> ClientConfig:
         pass
 
     @abstractmethod
@@ -56,15 +56,22 @@ def add_wrappers(self, wrapper_uris: Optional[List[Uri]]) -> ClientConfig:
         pass
 
     @abstractmethod
-    def set_resolver(self) -> ClientConfig:
+    def set_resolver(self, resolver: IUriResolver) -> ClientConfig:
         pass
 
+    @abstractmethod
+    def add_resolver(self, resolver: IUriResolver) -> ClientConfig:
+        pass
+
+    @abstractmethod
+    def add_resolvers(self, resolvers_list: List[IUriResolver]) -> ClientConfig:
+        pass
 class BaseClientConfigBuilder(IClientConfigBuilder):
     """A concrete class of the Client Config Builder, which uses the IClientConfigBuilder Abstract Base Class"""
     # config: ClientConfig
 
     def __init__(self):
-        self.config = ClientConfig(envs={}, interfaces={}, resolver=None, wrappers= [])
+        self.config = ClientConfig(envs={}, interfaces={}, resolver=[], wrappers= [])
 
     def build(self)-> ClientConfig:
         """
@@ -75,33 +82,33 @@ def build(self)-> ClientConfig:
     def get_envs(self)-> Dict[Uri, Dict[str, Any]]:
         return self.config.envs
 
-    def set_env(self, env: Env={'test':'tested'}, uri=Uri("wrap://ens/eth.plugin.one"))-> IClientConfigBuilder:
+    def set_env(self, env: Env={'test':'tested'}, uri: Uri=Uri("wrap://ens/eth.plugin.one"))-> IClientConfigBuilder:
         # TODO:  This is a temporary solution to the problem of the Uri / Env not being able to pass as None initially 
         # should be (self, env: Env=None, uri: Uri=None):  but that causes an error
         if (env or uri) is None:
             raise KeyError("Must provide both an env or uri")
         self.config.envs[uri] = env
         return self
 
-        # for key in self.config.envs[uri].keys():
-        #     if key in env.keys():
-        #         self.config.envs[uri][key] = env[key]
-        #     else:
-        #         self.config.envs[uri][key] = None
-        # return self
-
     def add_env(self, env: Env = None , uri: Uri = None)-> IClientConfigBuilder:
+        """Adds an environment (in the form of an `Env`) for a given uri, without overwriting existing environments,
+        unless the env key already exists in the environment, then it will overwrite the existing value"""
         if (env or uri) is None:
             raise KeyError("Must provide both an env or uri")
-        self.config.envs[uri] = env
+        
+        if uri in self.config.envs.keys():
+            for key in env.keys():
+                self.config.envs[uri][key] = env[key]
+        else:
+            self.config.envs[uri] = env
         return self
 
-    def add_envs(self, envs: List[Env]) -> IClientConfigBuilder:
+    def add_envs(self, envs: List[Env], uri: Uri = None) -> IClientConfigBuilder:
         """
         Adds a list of environments (each in the form of an `Env`) for a given uri
         """
         for env in envs:
-            self.add_env(env)
+            self.add_env(env, uri )
         return self
 
     def add_interface_implementations(self, interface_uri: Uri, implementations_uris: List[Uri]) -> IClientConfigBuilder:
@@ -142,7 +149,25 @@ def set_resolver(self, uri_resolver) -> IClientConfigBuilder:
         """
         Sets a single resolver for the `ClientConfig` object before it is built
         """
-        self.config.resolver = uri_resolver
+        self.config.resolver = [uri_resolver]
+        return self
+
+    def add_resolver(self, resolver: IUriResolver) -> IClientConfigBuilder:
+        """
+        Adds a resolver to the list of resolvers
+        """
+
+        if self.config.resolver is None:
+            raise ValueError("This resolver is not set. Please set a resolver before adding resolvers.")
+        self.config.resolver.append(resolver)
+        return self
+
+    def add_resolvers(self, resolvers_list: List[IUriResolver]) -> IClientConfigBuilder:
+        """
+        Adds a list of resolvers to the list of resolvers
+        """
+        for resolver in resolvers_list:
+            self.add_resolver(resolver)
         return self
 
 class ClientConfigBuilder(BaseClientConfigBuilder):

packages/polywrap-client-config-builder/polywrap_client_config_builder/client_config_builder.py

@@ -11,9 +11,7 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.10"
-wasmtime = "^1.0.1"
 polywrap-core = { path = "../polywrap-core", develop = true }
-polywrap-wasm = { path = "../polywrap-wasm", develop = true }
 polywrap-result = { path = "../polywrap-result", develop = true }
 
 [tool.poetry.dev-dependencies]

packages/polywrap-client-config-builder/pyproject.toml

@@ -12,8 +12,10 @@
 
 env_varA = { 'color': "yellow", 'size': "large" }
 env_varB = { 'color': "red", 'size': "small" }
+env_varN = { 'dog': "poodle", 'season': "summer" }
 env_varM = { 'dog': "corgi", 'season': "autumn" }
 env_varN = { 'dog': "poodle", 'season': "summer" }
+env_varS = { 'vehicle': "scooter"}
 env_uriX = Uri("wrap://ens/eth.plugin.one")
 env_uriY = Uri("wrap://ipfs/filecoin.wrapper.two")
 
@@ -25,23 +27,49 @@ def test_client_config_builder_set_env():
     envs = { env_uriX: env_varA }
     ccb = ccb.set_env( env_varA, env_uriX)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs=envs, interfaces={}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs=envs, interfaces={}, resolver = [], wrappers=[]))
 
 def test_client_config_builder_add_env():
     ccb = ClientConfigBuilder() # instantiate new client config builder
     ccb = ccb.add_env(env = env_varA, uri = env_uriX) # add env to client config builder    
     client_config: ClientConfig = ccb.build() # build a client config object
     print(client_config)
-    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = [], wrappers=[]))
 
 def test_client_config_builder_add_env_updates_env_value():
     ccb = ClientConfigBuilder() # instantiate new client config builder
     ccb = ccb.add_env(env = env_varA, uri = env_uriX) # add env to client config builder
     client_config: ClientConfig = ccb.build() # build a client config object
-    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = [], wrappers=[]))
     ccb = ccb.add_env(env = env_varB, uri = env_uriX) # update value of env var on client config builder
     client_config: ClientConfig = ccb.build() # build a new client config object
-    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varB}, interfaces={}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varB}, interfaces={}, resolver = [], wrappers=[]))
+
+def test_client_config_builder_set_env_and_add_env_updates_and_add_values():
+    ccb = ClientConfigBuilder()
+    ccb = ccb.set_env(env_varA, env_uriX) # set the environment variables A
+    client_config: ClientConfig = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = [], wrappers=[]))
+
+    ccb = ccb.set_env(env_varB, env_uriX) # set new vars on the same Uri
+    client_config: ClientConfig = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varB}, interfaces={}, resolver = [], wrappers=[]))
+
+    ccb = ccb.add_env(env_varM, env_uriY) # add new env vars on a new Uri
+    client_config: ClientConfig = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(
+        envs={
+            env_uriX: env_varB,
+            env_uriY: env_varM
+        }, 
+        interfaces={}, resolver = [], wrappers=[]))
+
+    # add new env vars on the second Uri, while also updating the Env vars of dog and season
+    ccb = ccb.add_envs([env_varN, env_varS], env_uriY)
+    new_envs = {**env_varM, **env_varN, **env_varS}
+    print(new_envs)
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs = {env_uriX: env_varB, env_uriY: new_envs}, interfaces={}, resolver = [], wrappers=[]))
 
 # INTERFACES AND IMPLEMENTATIONS
 
@@ -51,7 +79,7 @@ def test_client_config_builder_adds_interface_implementations():
     implementations_uris = [Uri("wrap://ens/eth.plugin.one"), Uri("wrap://ens/eth.plugin.two")]
     ccb = ccb.add_interface_implementations(interfaces_uri, implementations_uris)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={interfaces_uri: implementations_uris}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={interfaces_uri: implementations_uris}, resolver = [], wrappers=[]))
 
 # WRAPPERS AND PLUGINS
 
@@ -60,24 +88,24 @@ def test_client_config_builder_add_wrapper():
     wrapper = Uri("wrap://ens/uni.wrapper.eth")
     ccb = ccb.add_wrapper(wrapper)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = None, wrappers=[wrapper]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[wrapper]))
 
 def test_client_config_builder_adds_multiple_wrappers():
     ccb = ClientConfigBuilder()
     wrappers = [Uri("wrap://ens/uni.wrapper.eth"), Uri("wrap://ens/https.plugin.eth")]
     ccb = ccb.add_wrappers(wrappers)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = None, wrappers=wrappers))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=wrappers))
 
 def test_client_config_builder_removes_wrapper():
     ccb = ClientConfigBuilder()
     wrapper = Uri("wrap://ens/uni.wrapper.eth")
     ccb = ccb.add_wrapper(wrapper)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = None, wrappers=[wrapper]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[wrapper]))
     ccb = ccb.remove_wrapper(wrapper)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[]))
 
 # RESOLVER 
 
@@ -89,4 +117,26 @@ def test_client_config_builder_set_uri_resolver():
     ccb = ccb.set_resolver()
     client_config = ccb.build()
     assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=resolver, wrappers=[]))
-    
+    
+def test_client_config_builder_add_resolver():
+
+    # set a first resolver
+    ccb = ClientConfigBuilder()
+    resolverA = Uri("wrap://ens/eth.resolver.one")
+    ccb: ClientConfigBuilder = ccb.set_resolver(resolverA)
+    client_config: ClientConfig = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=[resolverA], wrappers=[]))
+    
+    # add a second resolver
+    resolverB = Uri("wrap://ens/eth.resolver.two")
+    ccb = ccb.add_resolver(resolverB)
+    client_config: ClientConfig = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=[resolverA, resolverB], wrappers=[]))
+
+    # add a third and fourth resolver
+    resolverC = Uri("wrap://ens/eth.resolver.three")
+    resolverD = Uri("wrap://ens/eth.resolver.four")
+    ccb = ccb.add_resolvers([resolverC, resolverD])
+    client_config: ClientConfig = ccb.build()
+    resolvers = [resolverA, resolverB, resolverC, resolverD]
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=resolvers, wrappers=[]))

packages/polywrap-client-config-builder/tests/test_client_config_builder.py

@@ -9,7 +9,7 @@ def test_client_config_structure_starts_empty():
     result = ClientConfig(
         envs={},
         interfaces={}, 
-        resolver = None,
+        resolver = [],
         wrappers = []
         )
     assert asdict(client_config) == asdict(result)
@@ -24,5 +24,5 @@ def test_client_config_structure_sets_env():
         env = env
         )
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={uri: env}, interfaces={}, resolver = None, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={uri: env}, interfaces={}, resolver = [], wrappers=[]))