fix: typing issues and refactor code

Author: Niraj-Kamdar

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

@@ -2,6 +2,7 @@
 
 import re
 from dataclasses import dataclass
+from functools import total_ordering
 from typing import Any, List, Optional, Tuple, Union
 
 
@@ -14,6 +15,7 @@ class UriConfig:
     uri: str
 
 
+@total_ordering
 class Uri:
     """
     A Polywrap URI.

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

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from polywrap_result import Result
 
@@ -16,4 +16,4 @@ class IUriResolutionStep:
     source_uri: Uri
     result: Result["UriPackageOrWrapper"]
     description: Optional[str] = None
-    sub_history: Optional["IUriResolutionStep"] = None
+    sub_history: Optional[List["IUriResolutionStep"]] = None

packages/polywrap-msgpack/polywrap_msgpack/__init__.py

@@ -59,7 +59,7 @@ def sanitize(value: Any) -> Any:
         array: List[Any] = value
         return [sanitize(a) for a in array]
     if isinstance(value, tuple):
-        array: List[Any] = list(value)  # type: ignore
+        array: List[Any] = list(value)  # type: ignore partially unknown
         return sanitize(array)
     if isinstance(value, set):
         set_val: Set[Any] = value

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

@@ -1,16 +1,23 @@
 from abc import ABC, abstractmethod
 
-from polywrap_core import IUriResolver, Uri, IUriResolutionContext, UriPackageOrWrapper, Client, IUriResolutionStep
+from polywrap_core import (
+    IUriResolver,
+    Uri,
+    IUriResolutionContext,
+    UriPackageOrWrapper,
+    Client,
+    IUriResolutionStep,
+)
 from polywrap_result import Result
 
 
 class IResolverWithHistory(IUriResolver, ABC):
-    async def try_resolve_uri(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext):
+    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(
-            source_uri=uri, 
-            result=result, 
-            description=self.get_step_description()
+            source_uri=uri, result=result, description=self.get_step_description()
         )
         resolution_context.track_step(step)
 
@@ -21,5 +28,7 @@ def get_step_description(self) -> str:
         pass
 
     @abstractmethod
-    async def _try_resolve_uri(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext) -> Result["UriPackageOrWrapper"]:
+    async def _try_resolve_uri(
+        self, uri: Uri, client: Client, resolution_context: IUriResolutionContext
+    ) -> Result["UriPackageOrWrapper"]:
         pass

…gregator/uri_resolver_aggregator_base.py …resolvers/abc/uri_resolver_aggregator.pypackages/polywrap-uri-resolvers/polywrap_uri_resolvers/aggregator/uri_resolver_aggregator_base.py renamed to packages/polywrap-uri-resolvers/polywrap_uri_resolvers/abc/uri_resolver_aggregator.py packages/polywrap-uri-resolvers/polywrap_uri_resolvers/aggregator/uri_resolver_aggregator_base.py renamed to packages/polywrap-uri-resolvers/polywrap_uri_resolvers/abc/uri_resolver_aggregator.py

@@ -4,7 +4,7 @@
 from polywrap_core import UriResolutionResult, IUriResolutionStep, IUriResolver, Uri, IUriResolutionContext, Client, UriPackageOrWrapper
 from polywrap_result import Result, Err
 
-class UriResolverAggregatorBase(IUriResolver, ABC):
+class IUriResolverAggregator(IUriResolver, ABC):
     @abstractmethod
     async def get_uri_resolvers(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext) -> Result[List[IUriResolver]]:
         pass
@@ -42,7 +42,7 @@ async def try_resolve_uri_with_resolvers(self, uri: Uri, client: Client, resolve
                 step = IUriResolutionStep(
                     source_uri=uri,
                     result=result,
-                    sub_history=sub_context.get_history(),
+                    sub_history=sub_context.get_history(), 
                     description=self.get_step_description()
                 )
                 resolution_context.track_step(step)
@@ -54,8 +54,8 @@ async def try_resolve_uri_with_resolvers(self, uri: Uri, client: Client, resolve
         step = IUriResolutionStep(
             source_uri=uri,
             result=result,
-            sub_history=sub_context.get_history(),  # type: ignore
-            description=self.get_step_description() # type: ignore
+            sub_history=sub_context.get_history(),
+            description=self.get_step_description()
         )
         resolution_context.track_step(step)
 

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/aggregator/__init__.py

@@ -1,2 +1,2 @@
-from .uri_resolver_aggregator_base import *
+from ..abc.uri_resolver_aggregator import *
 from .uri_resolver_aggregator import *

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/aggregator/uri_resolver_aggregator.py

@@ -3,9 +3,9 @@
 from polywrap_core import IUriResolver, Uri, IUriResolutionContext, Client
 from polywrap_result import Result, Ok
 
-from .uri_resolver_aggregator_base import UriResolverAggregatorBase
+from ..abc.uri_resolver_aggregator import IUriResolverAggregator
 
-class UriResolverAggregator(UriResolverAggregatorBase):
+class UriResolverAggregator(IUriResolverAggregator):
     resolvers: List[IUriResolver]
     name: Optional[str]
 
@@ -15,5 +15,5 @@ def __init__(self, resolvers: List[IUriResolver]):
     def get_step_description(self) -> str:
       return self.name or "UriResolverAggregator"
 
-    def get_uri_resolvers(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext) -> Result[List[IUriResolver]]:
+    async def get_uri_resolvers(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext) -> Result[List[IUriResolver]]:
       return Ok(self.resolvers)

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

@@ -9,13 +9,24 @@
 
 
 # TODO: Recheck if this should return result or not
-def build_resolver(uri_resolver_like: UriResolverLike, name: Optional[str]) -> IUriResolver:    
-    if type(uri_resolver_like) == list:
-        resolvers: List[IUriResolver] = list(map(lambda r: build_resolver(cast(UriResolverLike, r), name), uri_resolver_like)) # type: ignore
-        return UriResolverAggregator(resolvers)  # type: ignore
+def build_resolver(
+    uri_resolver_like: UriResolverLike, name: Optional[str]
+) -> IUriResolver:
+    if isinstance(uri_resolver_like, list):
+        resolvers: List[IUriResolver] = list(
+            map(
+                lambda r: build_resolver(r, name),
+                uri_resolver_like,
+            )
+        )
+        return UriResolverAggregator(resolvers)
     elif isinstance(uri_resolver_like, UriPackage):
-        return PackageResolver(uri=uri_resolver_like.uri, wrap_package=uri_resolver_like.package)  # type: ignore
+        return PackageResolver(
+            uri=uri_resolver_like.uri, wrap_package=uri_resolver_like.package
+        )
     elif isinstance(uri_resolver_like, UriWrapper):
-        return WrapperResolver(uri=uri_resolver_like.uri, wrapper=uri_resolver_like.wrapper)  # type: ignore
+        return WrapperResolver(
+            uri=uri_resolver_like.uri, wrapper=uri_resolver_like.wrapper
+        )
     else:
-        raise "Unknown resolver-like type" # type: ignore
+        raise ValueError("Unknown resolver-like value")

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

@@ -1,51 +1,48 @@
-from functools import reduce
 from typing import List, cast
-from aggregator import UriResolverAggregatorBase
-from polywrap_core import Uri, Client, IUriResolutionContext, IUriResolver, UriPackageOrWrapper
+from aggregator import IUriResolverAggregator
+from polywrap_core import (
+    Uri,
+    Client,
+    IUriResolutionContext,
+    IUriResolver,
+    UriPackageOrWrapper,
+)
 from polywrap_result import Result, Err, Ok
 from polywrap_uri_resolvers import UriResolverWrapper
-class ExtendableUriResolver(UriResolverAggregatorBase):
+
+
+class ExtendableUriResolver(IUriResolverAggregator):
     name: str
 
     def __init__(self, name: str):
         self.name = name
 
-    async def get_uri_resolvers(self, uri: Uri, client: Client, resolution_context: IUriResolutionContext) -> Result[List[IUriResolver]]:
+    async def get_uri_resolvers(
+        self, uri: Uri, client: Client, resolution_context: IUriResolutionContext
+    ) -> Result[List[IUriResolver]]:
         result = client.get_implementations(uri)
 
         if result.is_err():
             return cast(Err, result)
-    
-        def get_wrapper_resolvers(implementation_uri: Uri, resolvers: List[UriResolverWrapper]) -> List[IUriResolver]:
-            if not resolution_context.is_resolving(implementation_uri):
-                resolver_wrapper = UriResolverWrapper(implementation_uri)
-                resolvers.append(resolver_wrapper)
-            
-            return cast(List[IUriResolver], resolvers)
 
-        return Ok(reduce(get_wrapper_resolvers, result.value)) # type: ignore
+        uri_resolver_impls: List[Uri] = result.unwrap() or []
+
+        resolvers: List[IUriResolver] = [
+            UriResolverWrapper(impl)
+            for impl in uri_resolver_impls
+            if not resolution_context.is_resolving(impl)
+        ]
+
+        return Ok(resolvers)
 
     async def try_resolve_uri(
-        self,
-        uri: Uri,
-        client: Client,
-        resolution_context: IUriResolutionContext
+        self, uri: Uri, client: Client, resolution_context: IUriResolutionContext
     ) -> Result[UriPackageOrWrapper]:
-        result = await self.get_uri_resolvers(
-            uri, client, resolution_context
-        )
+        result = await self.get_uri_resolvers(uri, client, resolution_context)
 
         if result.is_err():
             return cast(Err, result)
 
-        resolvers: List[IUriResolver] = result.value # type: ignore
-
-        if len(resolvers) == 0:
-            return Ok(uri)
+        resolvers = result.unwrap()
 
-        return await self.try_resolve_uri_with_resolvers(
-            uri,
-            client,
-            resolvers,
-            resolution_context
-        )
+        return await self.try_resolve_uri_with_resolvers(uri, client, resolvers, resolution_context) if resolvers else Ok(uri)

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/helpers/infinite_loop_error.py

@@ -4,4 +4,4 @@
 class InfiniteLoopError(Exception):
     def __init__(self, uri: Uri, history: List[IUriResolutionStep]):
         # TODO: Add history with get_resolution_stack
-        self.message = f"An infinite loop was detected while resolving the URI: {uri.uri}"
+        super().__init__(f"An infinite loop was detected while resolving the URI: {uri.uri}")