feat: start implementation of uri resolver wrapper

Author: cbrzn

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

@@ -1,4 +1,9 @@
+from .abc import *
+from .aggregator import *
+from .helpers import *
 from .legacy import *
 from .fs_resolver import *
 from .legacy.redirect_resolver import *
 from .static_resolver import *
+from recursive_resolver import *
+from .uri_resolver_wrapper import *

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

@@ -2,11 +2,11 @@
 from typing import List
 
 from polywrap_core import UriResolutionResult, IUriResolutionStep, IUriResolver, Uri, IUriResolutionContext, Client, UriPackageOrWrapper
-from polywrap_result import Result, Ok
+from polywrap_result import Result
 
 class UriResolverAggregatorBase(IUriResolver, ABC):
     @abstractmethod
-    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]]:
         pass
 
     @abstractmethod

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

@@ -1,5 +1,51 @@
+from functools import reduce
+from typing import List, cast
 from aggregator import UriResolverAggregatorBase
-
+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):
-    def __init__(self):
-        pass
+    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]]:
+        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
+
+    async def try_resolve_uri(
+        self,
+        uri: Uri,
+        client: Client,
+        resolution_context: IUriResolutionContext
+    ) -> Result[UriPackageOrWrapper]:
+        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)
+
+        return await self.try_resolve_uri_with_resolvers(
+            uri,
+            client,
+            resolvers,
+            resolution_context
+        )

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

@@ -0,0 +1,36 @@
+from typing import Optional, Union, cast
+from polywrap_core import Uri, Client, IUriResolutionContext, UriPackageOrWrapper
+from polywrap_uri_resolvers import ResolverWithHistory
+from polywrap_result import Result, Ok, Err
+
+class UriResolverWrapper(ResolverWithHistory):
+    implementation_uri: Uri
+
+    def __init__(self, uri: Uri) -> None:
+        self.implementation_uri = uri
+
+    def get_step_description(self) -> str:
+        return super().get_step_description()
+
+    async def _try_resolve_uri(
+        self, 
+        uri: Uri, 
+        client: Client, 
+        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)
+
+        return Ok()
+
+
+
+async def try_resolve_uri_with_implementation(
+    uri: Uri,
+    implementation_uri: Uri,
+    client: Client,
+    resolution_context: IUriResolutionContext
+) -> Result[Optional[Union[str, bytearray]]]:
+    return Ok("")