feat: packages refactor, added generic add function, plus a tests suite for configuring packages, readme.

Author: rihp

packages/polywrap-client-config-builder/README.md

@@ -4,11 +4,11 @@
 
 These objects are needed to configure your python client's wrappers, pluggins, env variables, resolvers and interfaces.
 
-Look at [this file][./client_config_builder.py] to detail all of its functionality
-# Polywrap Python Client
-## This object allows you to build proper Polywrapt ClientConfig objects
+Look at [this file](./polywrap_client_config_builder/client_config_builder.py) to detail all of its functionality
+And at [tests](./tests/test_client_config_builder.py)
 
-These objects are needed to configure your python client's wrappers, pluggins, env variables, resolvers and interfaces.
+---
 
-Look at [this file](./polywrap_client_config_builder/client_config_builder.py) to detail all of its functionality
-And at [tests](./tests/test_client_config_builder.py)
+The current implementation uses the `ClientConfig` as a dataclass to later create an Abstract Base Class of a `BaseClientConfigBuilder` which defines more clearly the functions of the module, like add_envs, set_resolvers, remove_wrappers, and so on.  
+
+This `BaseClientConfigBuilder` is later used in the class `ClientConfigBuilder` which only implements the build method, for now, and inherits all the abstract methods of the `BaseClientConfigBuilder`.

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

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from polywrap_core import Uri, IUriResolver, Env
+from polywrap_core import Uri, IUriResolver, Env, UriWrapper,UriPackage
+from polywrap_uri_resolvers import IUriResolver
 from typing import Dict, Any, List, Optional, Union
 
 @dataclass(slots=True, kw_only=True) 
@@ -11,8 +12,9 @@ class ClientConfig():
     """
     envs: Dict[Uri, Dict[str, Any]]
     interfaces: Dict[Uri, List[Uri]]
+    packages: List[UriPackage]
     resolver: List[IUriResolver]
-    wrappers: List[Uri]
+    wrappers: List[UriWrapper]
 
 
 class BaseClientConfigBuilder(ABC):
@@ -22,13 +24,28 @@ class BaseClientConfigBuilder(ABC):
     """
 
     def __init__(self):
-        self.config = ClientConfig(envs={}, interfaces={}, resolver=[], wrappers= [])
+        self.config = ClientConfig(envs={}, interfaces={}, resolver=[], wrappers= [], packages=[])
 
     @abstractmethod
     def build(self) -> ClientConfig:
         """Returns a sanitized config object from the builder's config."""
         pass
 
+    @abstractmethod
+    def add(self, new_config: ClientConfig) -> ClientConfig:
+        """Returns a sanitized config object from the builder's config after receiving a partial `ClientConfig` object."""
+        if new_config.envs:
+            self.config.envs.update(new_config.envs)
+        if new_config.interfaces:
+            self.config.interfaces.update(new_config.interfaces)
+        if new_config.resolver:
+            self.config.resolver.extend(new_config.resolver)
+        if new_config.wrappers:
+            self.config.wrappers.extend(new_config.wrappers)
+        if new_config.packages:
+            self.config.packages.extend(new_config.packages)
+        return self.config
+
     @abstractmethod
     def get_envs(self)-> Dict[Uri, Dict[str, Any]]:
         """Returns the envs dictionary from the builder's config."""
@@ -37,13 +54,11 @@ def get_envs(self)-> Dict[Uri, Dict[str, Any]]:
     @abstractmethod    
     def set_env(self, env: Env, uri: Uri):
         """Sets the envs dictionary in the builder's config, overiding any existing values."""
-        if (env or uri) is None:
-            raise KeyError("Must provide both an env or uri")
         self.config.envs[uri] = env
         return self
 
     @abstractmethod
-    def add_env(self, env: Env = None , uri: Uri = None):
+    def add_env(self, env: Env, uri: Uri):
         """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:
@@ -103,6 +118,39 @@ def remove_wrapper(self, wrapper_uri: Uri) :
         self.config.wrappers.remove(wrapper_uri)
         return self
 
+    @abstractmethod
+    def set_package(self, uri_package: UriPackage):
+        """
+        Sets the package in the builder's config, overiding any existing values.
+        """
+        self.config.packages = [uri_package]
+        return self
+
+    @abstractmethod
+    def add_package(self, uri_package: UriPackage):
+        """
+        Adds a package to the list of packages
+        """
+        self.config.packages.append(uri_package)
+        return self
+    
+    @abstractmethod
+    def add_packages(self, uri_packages: List[UriPackage]):
+        """
+        Adds a list of packages to the list of packages
+        """
+        for uri_package in uri_packages:
+            self.add_package(uri_package)
+        return self
+
+    @abstractmethod
+    def remove_package(self, uri_package: UriPackage):
+        """
+        Removes a package from the list of packages
+        """
+        self.config.packages.remove(uri_package)
+        return self
+
     @abstractmethod
     def set_resolver(self, uri_resolver):
         """
@@ -139,6 +187,13 @@ def build(self)-> ClientConfig:
         """
         return self.config
 
+    def add(self, new_config: ClientConfig) -> ClientConfig:
+        """
+        Returns a sanitized config object from the builder's config after receiving a partial `ClientConfig` object.
+        """
+        super().add(new_config)
+        return self.config  
+
     def get_envs(self) -> Dict[Uri, Dict[str, Any]]:
         return super().get_envs()
 
@@ -170,6 +225,22 @@ def remove_wrapper(self, wrapper_uri: Uri)-> BaseClientConfigBuilder:
         super().remove_wrapper(wrapper_uri)
         return self 
 
+    def set_package(self, uri_package: UriPackage)-> BaseClientConfigBuilder:
+        super().set_package(uri_package)
+        return self
+
+    def add_package(self, uri_package: UriPackage)-> BaseClientConfigBuilder:
+        super().add_package(uri_package)
+        return self
+
+    def add_packages(self, uri_packages: List[UriPackage])-> BaseClientConfigBuilder:
+        super().add_packages(uri_packages)
+        return self
+
+    def remove_package(self, uri_package: UriPackage)-> BaseClientConfigBuilder:
+        super().remove_package(uri_package)
+        return self
+
     def set_resolver(self, uri_resolver: IUriResolver)-> BaseClientConfigBuilder:
         super().set_resolver(uri_resolver)
         return self

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

@@ -1,7 +1,7 @@
 from typing import List, Any, Dict, Union
 from polywrap_core import Env
 from polywrap_core import  Uri
-from polywrap_core import IUriResolver
+from polywrap_core import IUriResolver, UriPackage, UriWrapper
 from polywrap_client_config_builder import ClientConfigBuilder
 import pytest
 from pytest import fixture
@@ -27,33 +27,33 @@ 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 = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs=envs, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
 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 = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
 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 = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = [], wrappers=[], packages=[]))
     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 = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varB}, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
 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=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varA}, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
     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=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={env_uriX: env_varB}, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
     ccb = ccb.add_env(env_varM, env_uriY) # add new env vars on a new Uri
     client_config: ClientConfig = ccb.build()
@@ -62,14 +62,14 @@ def test_client_config_builder_set_env_and_add_env_updates_and_add_values():
             env_uriX: env_varB,
             env_uriY: env_varM
         }, 
-        interfaces={}, resolver = [], wrappers=[]))
+        interfaces={}, resolver = [], wrappers=[], packages=[]))
 
     # 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=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs = {env_uriX: env_varB, env_uriY: new_envs}, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
 # INTERFACES AND IMPLEMENTATIONS
 
@@ -79,7 +79,58 @@ 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 = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={interfaces_uri: implementations_uris}, resolver = [], wrappers=[], packages=[]))
+
+# PACKAGES
+
+@pytest.mark.skip("Should implement UriPackage interface with package argument")
+def test_client_config_builder_set_package():
+    ccb = ClientConfigBuilder()
+    package = UriPackage(Uri("wrap://ens/uni.wrapper.eth"), version="1.0.0")
+    ccb = ccb.set_package(package)
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package]))
+
+@pytest.mark.skip("Should implement UriPackage interface with package argument")
+def test_client_config_builder_add_package():
+    ccb = ClientConfigBuilder()
+    package = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    ccb = ccb.add_package(package)
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package]))
+
+@pytest.mark.skip("Should implement UriPackage interface with package argument")
+def test_client_config_builder_add_package_updates_package():
+    ccb = ClientConfigBuilder()
+    package = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    ccb = ccb.add_package(package)
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package]))
+    package = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    ccb = ccb.add_package(package)
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package]))
+
+@pytest.mark.skip("Should implement UriPackage interface with package argument")
+def test_client_config_builder_add_packages():
+    ccb = ClientConfigBuilder()
+    package = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    package2 = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    ccb = ccb.add_packages([package, package2])
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package, package2]))
+
+@pytest.mark.skip("Should implement UriPackage interface with package argument")
+def test_client_config_builder_add_packages_removes_packages():
+    ccb = ClientConfigBuilder()
+    package = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    package2 = UriPackage(Uri("wrap://ens/uni.wrapper.eth"))
+    ccb = ccb.add_packages([package, package2])
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package, package2]))
+    ccb = ccb.remove_package([package1])
+    client_config = ccb.build()
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[package2]))
 
 # WRAPPERS AND PLUGINS
 
@@ -88,24 +139,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 = [], wrappers=[wrapper]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[wrapper], packages=[]))
 
 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 = [], wrappers=wrappers))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=wrappers, packages=[]))
 
 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 = [], wrappers=[wrapper]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[wrapper], packages=[]))
     ccb = ccb.remove_wrapper(wrapper)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver = [], wrappers=[], packages=[]))
 
 # RESOLVER 
 
@@ -114,9 +165,9 @@ def test_client_config_builder_set_uri_resolver():
     ccb = ClientConfigBuilder()
     resolver =  IUriResolver()
     Uri("wrap://ens/eth.resolver.one")
-    ccb = ccb.set_resolver()
+    ccb = ccb.set_resolver(resolver)
     client_config = ccb.build()
-    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=resolver, wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=[resolver], wrappers=[], packages=[]))
 
 def test_client_config_builder_add_resolver():
 
@@ -125,18 +176,24 @@ def test_client_config_builder_add_resolver():
     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=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=[resolverA], wrappers=[], packages=[]))
 
     # 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=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=[resolverA, resolverB], wrappers=[], packages=[]))
 
     # 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=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={}, interfaces={}, resolver=resolvers, wrappers=[], packages=[]))
+
+# TODO: add tests for the following methods
+
+def test_client_config_builder_generic_add():
+    # Test adding package, wrapper, resolver, interface, and env with the ccb.add method
+    pass

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

@@ -10,7 +10,8 @@ def test_client_config_structure_starts_empty():
         envs={},
         interfaces={}, 
         resolver = [],
-        wrappers = []
+        wrappers = [],
+        packages=[]
         )
     assert asdict(client_config) == asdict(result)
 
@@ -24,5 +25,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 = [], wrappers=[]))
+    assert asdict(client_config) == asdict(ClientConfig(envs={uri: env}, interfaces={}, resolver = [], wrappers=[], packages=[]))