chore: improve codebase with better code pratices

Author: cbrzn

packages/polywrap-client/tests/test_client.py

@@ -57,7 +57,7 @@ async def test_invoke(
         manifest=simple_wrap_manifest
     )
     uri_wrapper = UriWrapper(uri=Uri("ens/wrapper.eth"), wrapper=wrapper)
-    resolver = StaticResolver._from([uri_wrapper])
+    resolver = StaticResolver.from_list([uri_wrapper]).unwrap()
 
     config = PolywrapClientConfig(resolver=resolver)
     client = PolywrapClient(config=config)

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/abc/resolver_with_history.py

@@ -4,7 +4,7 @@
 from polywrap_result import Result
 
 
-class ResolverWithHistory(IUriResolver, ABC):
+class IResolverWithHistory(IUriResolver, ABC):
     async def try_resolve_uri(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext):
         result = await self._try_resolve_uri(uri, client, resolution_context)
         step = IUriResolutionStep(

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/package_resolver.py

@@ -1,9 +1,9 @@
-from .abc import ResolverWithHistory
+from .abc import IResolverWithHistory
 from polywrap_core import Uri, UriPackageOrWrapper, IWrapPackage, UriResolutionResult
 from polywrap_result import Result
 
 
-class PackageResolver(ResolverWithHistory):
+class PackageResolver(IResolverWithHistory):
     uri: Uri
     wrap_package: IWrapPackage
 

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/static_resolver.py

@@ -1,6 +1,6 @@
 from typing import List, cast
 from polywrap_core import IUriResolutionStep, Wrapper, IWrapPackage, UriResolutionResult, IUriResolver, UriPackageOrWrapper, Uri, Client, IUriResolutionContext, UriPackage, UriWrapper
-from polywrap_result import Result
+from polywrap_result import Result, Err, Ok
 
 from .helpers import UriResolverLike
 
@@ -12,37 +12,42 @@ def __init__(self, uri_map: dict[str, UriPackageOrWrapper]):
         self.uri_map = uri_map
 
     @staticmethod
-    def _from(static_resolver_likes: List[UriResolverLike]) -> "StaticResolver":
+    def from_list(static_resolver_likes: List[UriResolverLike]) -> Result["StaticResolver"]:
         uri_map: dict[str, UriPackageOrWrapper] = dict()
         for static_resolver_like in static_resolver_likes:
             if type(static_resolver_like) == list:
-                resolver = StaticResolver._from(cast(List[UriResolverLike], static_resolver_like))
-                for uri, package_or_wrapper in resolver.uri_map.items():
+                resolver = StaticResolver.from_list(cast(List[UriResolverLike], static_resolver_like))
+                for uri, package_or_wrapper in resolver.unwrap().uri_map.items():
                     uri_map[uri] = package_or_wrapper
 
-            elif hasattr(static_resolver_like, "uri") and hasattr(static_resolver_like, "package"):
+            elif isinstance(static_resolver_like, UriPackage):
                 uri_package = UriPackage(uri=static_resolver_like.uri, package=static_resolver_like.package) # type: ignore
                 uri_map[uri_package.uri.uri] = uri_package
-            elif hasattr(static_resolver_like, "uri") and hasattr(static_resolver_like, "wrapper"):
+            elif isinstance(static_resolver_like, UriWrapper):
                 uri_wrapper = UriWrapper(uri=static_resolver_like.uri, wrapper=static_resolver_like.wrapper) # type: ignore
                 uri_map[uri_wrapper.uri.uri] = uri_wrapper
+            elif isinstance(static_resolver_like, Uri):
+                uri_map[static_resolver_like.uri] = static_resolver_like
             else:
-                raise Exception("Unknown static-resolver-like type provided.")
+                return Err(Exception("Unknown static-resolver-like type provided."))
 
-        return StaticResolver(uri_map)
+        return Ok(StaticResolver(uri_map))
 
     async def try_resolve_uri(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext) -> Result["UriPackageOrWrapper"]:
-        package_or_wrapper = self.uri_map.get(uri.uri)
+        uri_package_or_wrapper = self.uri_map.get(uri.uri)
 
         result: Result[UriPackageOrWrapper] = UriResolutionResult.ok(uri)
         description: str = "StaticResolver - Miss"
 
-        if package_or_wrapper:
-            if hasattr(package_or_wrapper, "package"):
-                result = UriResolutionResult.ok(uri, cast(IWrapPackage, package_or_wrapper.package))
+        if uri_package_or_wrapper:
+            if isinstance(uri_package_or_wrapper, UriPackage):
+                result = UriResolutionResult.ok(uri, uri_package_or_wrapper.package)
                 description = f"Static - Package ({uri.uri})"
-            elif hasattr(package_or_wrapper, "wrapper"):
-                result = UriResolutionResult.ok(uri, None, cast(Wrapper, package_or_wrapper.wrapper))
+            elif isinstance(uri_package_or_wrapper, UriWrapper):
+                result = UriResolutionResult.ok(uri, None, uri_package_or_wrapper.wrapper)
+                description = f"Static - Wrapper ({uri.uri})"
+            elif isinstance(uri_package_or_wrapper, Uri):
+                result = UriResolutionResult.ok(uri)
                 description = f"Static - Wrapper ({uri.uri})"
 
         step = IUriResolutionStep(source_uri=uri, result=result, description=description)

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/uri_resolver_wrapper.py

@@ -1,16 +1,16 @@
 from typing import Optional, Union, cast
 from polywrap_core import Uri, Client, IUriResolutionContext, UriPackageOrWrapper
-from polywrap_uri_resolvers import ResolverWithHistory
+from polywrap_uri_resolvers import IResolverWithHistory
 from polywrap_result import Result, Ok, Err
 
-class UriResolverWrapper(ResolverWithHistory):
+class UriResolverWrapper(IResolverWithHistory):
     implementation_uri: Uri
 
     def __init__(self, uri: Uri) -> None:
         self.implementation_uri = uri
 
     def get_step_description(self) -> str:
-        return super().get_step_description()
+        return ""
 
     async def _try_resolve_uri(
         self, 
@@ -19,7 +19,7 @@ async def _try_resolve_uri(
         resolution_context: IUriResolutionContext
     ) -> Result[UriPackageOrWrapper]:
         result = await try_resolve_uri_with_implementation(uri, self.implementation_uri, client, resolution_context)
-        
+
         if result.is_err():
             return cast(Err, result)
 

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/wrapper_resolver.py

@@ -1,9 +1,9 @@
-from .abc import ResolverWithHistory
+from .abc import IResolverWithHistory
 from polywrap_core import Uri, UriPackageOrWrapper, Wrapper, UriResolutionResult
 from polywrap_result import Result
 
 
-class WrapperResolver(ResolverWithHistory):
+class WrapperResolver(IResolverWithHistory):
     uri: Uri
     wrapper: Wrapper
 

packages/polywrap-uri-resolvers/tests/test_static_resolver.py

@@ -48,9 +48,9 @@ async def test_static_resolver(
     uri_wrapper = UriWrapper(uri=Uri("ens/wrapper.eth"), wrapper=wrapper)
     uri_package = UriPackage(uri=Uri("ens/package.eth"), package=package)
 
-    resolver = StaticResolver._from([ uri_package, uri_wrapper, [
+    resolver = StaticResolver.from_list([ uri_package, uri_wrapper, [
         UriPackage(uri=Uri("ens/nested-package.eth"), package=package)
-    ]])
+    ]]).unwrap()
 
     resolution_context = UriResolutionContext()
     result = await resolver.try_resolve_uri(Uri("ens/package.eth"), PolywrapClient(), resolution_context)