refactor: polywrap-plugin package (#184)

Author: Niraj-Kamdar

packages/polywrap-client/tests/test_plugin_wrapper.py

@@ -0,0 +1 @@
+# Encode - Decode need to be tested

packages/polywrap-client/tests/test_wasm_wrapper.py

@@ -1,21 +1,42 @@
 """This module contains the PluginModule class."""
 # pylint: disable=invalid-name
 from abc import ABC
-from typing import Any, Generic, TypeVar
+from dataclasses import dataclass
+from typing import Any, Generic, Optional, TypeVar
 
 from polywrap_core import (
-    InvokeOptions,
-    Invoker,
-    UriPackageOrWrapper,
+    InvokerClient,
+    Uri,
+    UriResolutionContext,
     WrapAbortError,
     WrapInvocationError,
-    execute_maybe_async_function,
 )
 from polywrap_msgpack import msgpack_decode
 
 TConfig = TypeVar("TConfig")
 
 
+@dataclass(kw_only=True, slots=True)
+class InvokeOptions:
+    """InvokeOptions is a dataclass that holds the options for an invocation.
+
+    Attributes:
+        uri: The URI of the wrapper.
+        method: The method to invoke.
+        args: The arguments to pass to the method.
+        env: The environment variables to set for the invocation.
+        resolution_context: A URI resolution context.
+        client: The client to use for subinvocations.
+    """
+
+    uri: Uri
+    method: str
+    args: Optional[Any] = None
+    env: Optional[Any] = None
+    resolution_context: Optional[UriResolutionContext] = None
+    client: Optional[InvokerClient] = None
+
+
 class PluginModule(Generic[TConfig], ABC):
     """PluginModule is the base class for all plugin modules.
 
@@ -33,20 +54,17 @@ def __init__(self, config: TConfig):
         """
         self.config = config
 
-    async def __wrap_invoke__(
+    def __wrap_invoke__(
         self,
-        options: InvokeOptions[UriPackageOrWrapper],
-        invoker: Invoker[UriPackageOrWrapper],
+        options: InvokeOptions,
     ) -> Any:
         """Invoke a method on the plugin.
 
         Args:
-            method: The name of the method to invoke.
-            args: The arguments to pass to the method.
-            invoker: The invoker to use for subinvocations.
+            options: The options to use when invoking the plugin.
 
         Returns:
-            The result of the plugin method invocation or an error.
+            The result of the plugin method invocation.
         """
         if not hasattr(self, options.method):
             raise WrapInvocationError(
@@ -61,11 +79,12 @@ async def __wrap_invoke__(
                     if isinstance(options.args, bytes)
                     else options.args
                 )
-                return await execute_maybe_async_function(
-                    callable_method, decoded_args, invoker, options.env
-                )
+                return callable_method(decoded_args, options.client, options.env)
             except Exception as err:
                 raise WrapAbortError(options, repr(err)) from err
         raise WrapInvocationError(
             options, f"{options.method} is not a callable method in plugin module"
         )
+
+
+__all__ = ["PluginModule"]

packages/polywrap-plugin/node_modules/.yarn-integrity

@@ -2,16 +2,16 @@
 # pylint: disable=invalid-name
 from typing import Generic, Optional, TypeVar
 
-from polywrap_core import GetManifestOptions, UriPackageOrWrapper, WrapPackage, Wrapper
-from polywrap_manifest import AnyWrapManifest
+from polywrap_core import WrapPackage, Wrapper
+from polywrap_manifest import AnyWrapManifest, DeserializeManifestOptions
 
 from .module import PluginModule
 from .wrapper import PluginWrapper
 
 TConfig = TypeVar("TConfig")
 
 
-class PluginPackage(Generic[TConfig], WrapPackage[UriPackageOrWrapper]):
+class PluginPackage(WrapPackage, Generic[TConfig]):
     """PluginPackage implements IWrapPackage interface for the plugin.
 
     Attributes:
@@ -32,12 +32,12 @@ def __init__(self, module: PluginModule[TConfig], manifest: AnyWrapManifest):
         self.module = module
         self.manifest = manifest
 
-    async def create_wrapper(self) -> Wrapper[UriPackageOrWrapper]:
+    def create_wrapper(self) -> Wrapper:
         """Create a new plugin wrapper instance."""
         return PluginWrapper(module=self.module, manifest=self.manifest)
 
-    async def get_manifest(
-        self, options: Optional[GetManifestOptions] = None
+    def get_manifest(
+        self, options: Optional[DeserializeManifestOptions] = None
     ) -> AnyWrapManifest:
         """Get the manifest of the plugin.
 
@@ -48,3 +48,6 @@ async def get_manifest(
             The manifest of the plugin.
         """
         return self.manifest
+
+
+__all__ = ["PluginPackage"]

packages/polywrap-plugin/poetry.lock

@@ -0,0 +1,84 @@
+"""This module defines the ResolutionContextOverrideClient class."""
+from typing import Any, List, Optional
+
+from polywrap_core import InvokerClient, Uri, UriResolutionContext
+
+
+class ResolutionContextOverrideClient(InvokerClient):
+    """A client that overrides the resolution context of the wrapped client.
+
+    Args:
+        client (InvokerClient): The wrapped client.
+        resolution_context (Optional[UriResolutionContext]): The resolution context to use.
+    """
+
+    client: InvokerClient
+    resolution_context: Optional[UriResolutionContext]
+
+    __slots__ = ("client", "resolution_context")
+
+    def __init__(
+        self, client: InvokerClient, resolution_context: Optional[UriResolutionContext]
+    ):
+        """Initialize a new ResolutionContextOverrideClient instance."""
+        self.client = client
+        self.resolution_context = resolution_context
+
+    def invoke(
+        self,
+        uri: Uri,
+        method: str,
+        args: Optional[Any] = None,
+        env: Optional[Any] = None,
+        resolution_context: Optional[UriResolutionContext] = None,
+        encode_result: Optional[bool] = False,
+    ) -> Any:
+        """Invoke the Wrapper based on the provided InvokerOptions.
+
+        Args:
+            uri (Uri): Uri of the wrapper
+            method (str): Method to be executed
+            args (Optional[Any]) : Arguments for the method, structured as a dictionary
+            env (Optional[Any]): Override the client's config for all invokes within this invoke.
+            resolution_context (Optional[UriResolutionContext]): A URI resolution context
+            encode_result (Optional[bool]): If True, the result will be encoded
+
+        Returns:
+            Any: invocation result.
+        """
+        return self.client.invoke(
+            uri,
+            method,
+            args,
+            env,
+            self.resolution_context,
+            encode_result,
+        )
+
+    def get_implementations(
+        self, uri: Uri, apply_resolution: bool = True
+    ) -> Optional[List[Uri]]:
+        """Get implementations of an interface with its URI.
+
+        Args:
+            uri (Uri): URI of the interface.
+            apply_resolution (bool): If True, apply resolution to the URI and interfaces.
+
+        Returns:
+            Optional[List[Uri]]: List of implementations or None if not found.
+        """
+        return self.client.get_implementations(uri, apply_resolution)
+
+    def try_resolve_uri(
+        self, uri: Uri, resolution_context: UriResolutionContext | None = None
+    ) -> Any:
+        """Try to resolve a URI to a wrap package, a wrapper, or a URI.
+
+        Args:
+            uri (Uri): The URI to resolve.
+            resolution_context (UriResolutionContext): The resolution context.
+
+        Returns:
+            Any: URI Resolution Result.
+        """
+        return self.client.try_resolve_uri(uri, self.resolution_context)

packages/polywrap-plugin/polywrap_plugin/module.py

@@ -1,24 +1,25 @@
 """This module contains the PluginWrapper class."""
 # pylint: disable=invalid-name
-from typing import Generic, TypeVar, Union
+# pylint: disable=too-many-arguments
+from typing import Any, Generic, Optional, TypeVar, Union
 
 from polywrap_core import (
-    GetFileOptions,
     InvocableResult,
-    InvokeOptions,
-    Invoker,
-    UriPackageOrWrapper,
+    InvokerClient,
+    Uri,
+    UriResolutionContext,
     Wrapper,
 )
 from polywrap_manifest import AnyWrapManifest
 
-from .module import PluginModule
+from .module import InvokeOptions, PluginModule
+from .resolution_context_override_client import ResolutionContextOverrideClient
 
 TConfig = TypeVar("TConfig")
 TResult = TypeVar("TResult")
 
 
-class PluginWrapper(Generic[TConfig], Wrapper[UriPackageOrWrapper]):
+class PluginWrapper(Wrapper, Generic[TConfig]):
     """PluginWrapper implements the Wrapper interface for plugin wrappers.
 
     Attributes:
@@ -41,31 +42,53 @@ def __init__(
         self.module = module
         self.manifest = manifest
 
-    async def invoke(
+    def invoke(
         self,
-        options: InvokeOptions[UriPackageOrWrapper],
-        invoker: Invoker[UriPackageOrWrapper],
+        uri: Uri,
+        method: str,
+        args: Optional[Any] = None,
+        env: Optional[Any] = None,
+        resolution_context: Optional[UriResolutionContext] = None,
+        client: Optional[InvokerClient] = None,
     ) -> InvocableResult:
-        """Invoke a method on the plugin.
+        """Invoke the Wrapper based on the provided InvokeOptions.
 
         Args:
-            options (InvokeOptions): options to use when invoking the plugin.
-            invoker (Invoker): the invoker to use when invoking the plugin.
+            uri (Uri): Uri of the wrapper
+            method (str): Method to be executed
+            args (Optional[Any]) : Arguments for the method, structured as a dictionary
+            env (Optional[Any]): Override the client's config for all invokes within this invoke.
+            resolution_context (Optional[UriResolutionContext]): A URI resolution context
+            client (Optional[Invoker]): The invoker instance requesting this invocation.\
+                This invoker will be used for any subinvocation that may occur.
 
         Returns:
-            Result[InvocableResult]: the result of the invocation.
+            InvocableResult: Result of the invocation.
         """
-        result = await self.module.__wrap_invoke__(options, invoker)
+        options = InvokeOptions(
+            uri=uri,
+            method=method,
+            args=args,
+            env=env,
+            resolution_context=resolution_context,
+            client=ResolutionContextOverrideClient(client, resolution_context)
+            if client
+            else None,
+        )
+        result = self.module.__wrap_invoke__(options)
         return InvocableResult(result=result, encoded=False)
 
-    async def get_file(self, options: GetFileOptions) -> Union[str, bytes]:
-        """Get a file from the plugin.
+    def get_file(
+        self, path: str, encoding: Optional[str] = "utf-8"
+    ) -> Union[str, bytes]:
+        """Get a file from the wrapper.
 
         Args:
-            options (GetFileOptions): options to use when getting the file.
+            path (str): Path to the file.
+            encoding (Optional[str]): Encoding of the file.
 
         Returns:
-            Result[Union[str, bytes]]: the file contents or an error.
+            Union[str, bytes]: The file contents
         """
         raise NotImplementedError("client.get_file(..) is not implemented for plugins")
 
@@ -76,3 +99,6 @@ def get_manifest(self) -> AnyWrapManifest:
             Result[AnyWrapManifest]: the manifest of the plugin.
         """
         return self.manifest
+
+
+__all__ = ["PluginWrapper"]

packages/polywrap-plugin/polywrap_plugin/package.py

@@ -50,6 +50,7 @@ disable = [
     "too-many-return-statements",
     "broad-exception-caught",
     "too-few-public-methods",
+    "too-many-arguments",
 ]
 ignore = [
     "tests/"

packages/polywrap-plugin/polywrap_plugin/resolution_context_override_client.py

@@ -2,15 +2,15 @@
 from typing import Any, Dict, List, Union, Optional
 
 from polywrap_plugin import PluginModule
-from polywrap_core import Invoker, Uri, InvokerOptions, UriPackageOrWrapper, Env
+from polywrap_core import InvokerClient, Uri
 
 @fixture
-def invoker() -> Invoker[UriPackageOrWrapper]:
-    class MockInvoker(Invoker[UriPackageOrWrapper]):
-        async def invoke(self, options: InvokerOptions[UriPackageOrWrapper]) -> Any:
+def client() -> InvokerClient:
+    class MockInvoker(InvokerClient):
+        async def invoke(self, *args: Any) -> Any:
             raise NotImplementedError()
 
-        def get_implementations(self, uri: Uri) -> Union[List[Uri], None]:
+        def get_implementations(self, *args: Any) -> Union[List[Uri], None]:
             raise NotImplementedError()
 
     return MockInvoker()
@@ -22,7 +22,7 @@ class GreetingModule(PluginModule[None]):
         def __init__(self, config: None):
             super().__init__(config)
 
-        def greeting(self, args: Dict[str, Any], client: Invoker[UriPackageOrWrapper], env: Optional[Env] = None):
+        def greeting(self, args: Dict[str, Any], client: InvokerClient, env: Optional[Any] = None):
             return f"Greetings from: {args['name']}"
 
     return GreetingModule(None)