feat: plugin wrapper works as expected!

Author: cbrzn

packages/polywrap-plugin/polywrap_plugin/module.py

@@ -1,13 +1,13 @@
 from abc import ABC
 from typing import Any, Dict, TypeVar, Generic, List
-import inspect
 
 from polywrap_core import Invoker
-from polywrap_result import Err, Ok
+from polywrap_result import Err, Ok, Result
 
 TConfig = TypeVar('TConfig')
+TResult = TypeVar('TResult')
 
-class PluginModule(Generic[TConfig], ABC):
+class PluginModule(Generic[TConfig, TResult], ABC):
     env: Dict[str, Any]
     config: TConfig
 
@@ -17,21 +17,15 @@ def __init__(self, config: TConfig):
     def set_env(self, env: Dict[str, Any]) -> None:
         self.env = env
 
-    async def _wrap_invoke(self, method: str, args: Dict[str, Any], client: Invoker):
-        callable_method = self.get_method(method)      
-        if not method:
-            return Err(Exception(f"Plugin missing method {method}"))
+    async def _wrap_invoke(self, method: str, args: Dict[str, Any], client: Invoker) -> Result[TResult]:
+        methods: List[str] = [name for name in dir(self) if name == method]
 
-        result = callable_method(args, client)
-        print(result)
-        return result
+        if len(methods) == 0:
+            return Err(Exception(f"{method} is not defined in plugin"))
 
-    def get_method(self, method: str):
-        methods: List[str] = [name for name in dir(self) if name == method]
-        callable_method = getattr(self, methods[0])
+        callable_method = getattr(self, method)
 
-        # TODO: Change this to return Err instead of throwin
         if not callable(callable_method):
-            raise Exception(f"Method {method} is an attribute, not a method")
-        
-        return callable_method
+            return Err(Exception(f"{method} is an attribute, not a method"))
+
+        return Ok(callable_method(args, client))

packages/polywrap-plugin/polywrap_plugin/package.py

@@ -1,14 +1,17 @@
+from typing import Generic
+
 from polywrap_manifest import AnyWrapManifest
-from polywrap_plugin import PluginModule
+from polywrap_plugin import PluginModule, TConfig, TResult
 
-class PluginPackage:
-    module: PluginModule
+class PluginPackage(Generic[TConfig, TResult]):
+    module: PluginModule[TConfig, TResult]
     manifest: AnyWrapManifest
 
     def __init__(
         self, 
-        module: PluginModule,
+        module: PluginModule[TConfig, TResult],
         manifest: AnyWrapManifest
     ):
         self.module = module
-        self.manifest = manifest
+        self.manifest = manifest
+

packages/polywrap-plugin/polywrap_plugin/wrapper.py

@@ -1,39 +1,44 @@
-from typing import Union, Any, Dict
-
-from polywrap_core import Wrapper, InvokeOptions, Invoker, InvocableResult, GetFileOptions
-from polywrap_plugin import PluginModule
-from polywrap_result import Result, Ok, Err
+from typing import Any, Dict, Union, cast, Generic
+
+from polywrap_core import (
+    GetFileOptions,
+    InvocableResult,
+    InvokeOptions,
+    Invoker,
+    Wrapper
+)
 from polywrap_manifest import AnyWrapManifest
 from polywrap_msgpack import msgpack_decode
+from polywrap_result import Err, Ok, Result
+
+from polywrap_plugin import PluginModule, TConfig, TResult
 
-class PluginWrapper(Wrapper):
+class PluginWrapper(Wrapper, Generic[TConfig, TResult]):
+    module: PluginModule[TConfig, TResult]
     manifest: AnyWrapManifest
-    module: PluginModule
 
-    def __init__(self, manifest: AnyWrapManifest, module: PluginModule) -> None:
-        self.manifest = manifest
+    def __init__(self, module: PluginModule[TConfig, TResult], manifest: AnyWrapManifest) -> None:
         self.module = module
+        self.manifest = manifest
 
     async def invoke(
         self, options: InvokeOptions, invoker: Invoker
     ) -> Result[InvocableResult]:
-
-        method = options.method
-        if not self.module.get_method(method):
-            return Err(Exception(f"PluginWrapper: method {method} not found"))
-
         env = options.env if options.env else {}
         self.module.set_env(env)
 
-        decoded_args: Dict[str, Any] = options.args if options.args else {}
+        decoded_args: Union[Dict[str, Any], bytes] = options.args if options.args else {}
 
         if isinstance(decoded_args, bytes):
             decoded_args = msgpack_decode(decoded_args)
 
-        result = self.module._wrap_invoke(method, decoded_args, invoker)
+        result: Result[TResult] = await self.module._wrap_invoke(options.method, decoded_args, invoker) # type: ignore
+
+        if result.is_err():
+            return cast(Err, result.err)
+
+        return Ok(InvocableResult(result=result,encoded=False))
 
-        if result.ok:
-            return Ok(InvocableResult(result=result,encoded=False))
 
     async def get_file(self, options: GetFileOptions) -> Result[Union[str, bytes]]:
         return Err(Exception("client.get_file(..) is not implemented for plugins"))

…ywrap-plugin/tests/test_plugin_method.py …ywrap-plugin/tests/test_plugin_module.pypackages/polywrap-plugin/tests/test_plugin_method.py renamed to packages/polywrap-plugin/tests/test_plugin_module.py packages/polywrap-plugin/tests/test_plugin_method.py renamed to packages/polywrap-plugin/tests/test_plugin_module.py

@@ -1,15 +1,15 @@
-from typing import TypeVar, Dict, Any
+from typing import Any, Dict
 
 import pytest
 from polywrap_client import PolywrapClient
 from polywrap_core import Invoker
+from polywrap_result import Ok
 
 from polywrap_plugin import PluginModule
 
-TConfig = TypeVar('TConfig')
 
-class GreetingModule(PluginModule):
-    def __init__(self, config: TConfig):
+class GreetingModule(PluginModule[Any, str]):
+    def __init__(self, config: Any):
         super().__init__(config)
 
     def greeting(self, args: Dict[str, Any], client: Invoker):
@@ -20,6 +20,5 @@ async def test_plugin_module():
     plugin = GreetingModule({})
 
     client = PolywrapClient()
-    result = await plugin._wrap_invoke("greeting", { "name": "Joe" }, client)
-    print(result)
-    assert result, "Greetings from: Joe"
+    result = await plugin._wrap_invoke("greeting", { "name": "Joe" }, client) # type: ignore
+    assert result, Ok("Greetings from: Joe")

packages/polywrap-plugin/tests/test_plugin_wrapper.py

@@ -1,2 +1,31 @@
-def test_plugin_wrapper_invoke():
-    pass
+from typing import cast
+
+import pytest
+from polywrap_core import InvokeOptions, Uri
+from polywrap_manifest import AnyWrapManifest
+from polywrap_plugin import PluginWrapper
+from polywrap_client import PolywrapClient
+from polywrap_result import Ok
+
+from test_plugin_module import GreetingModule 
+
+@pytest.mark.asyncio
+async def test_plugin_wrapper_invoke():
+    module = GreetingModule({})
+    manifest = cast(AnyWrapManifest, {})
+
+    wrapper = PluginWrapper(module, manifest)
+
+
+    args = {
+        "name": "Joe"
+    }
+    options = InvokeOptions(
+        uri=Uri("ens/greeting.eth"),
+        method="greeting",
+        args=args
+    )
+
+    client = PolywrapClient()
+    result = await wrapper.invoke(options, client)
+    assert result, Ok("Greetings from: Joe")