refactor: polywrap-plugin package

packages/polywrap-client/tests/test_plugin_wrapper.py

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

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

@@ -1,16 +1,12 @@
 """This module contains all the core types used in the various polywrap packages."""
 from .client import *
 from .config import *
-from .env import *
 from .errors import *
 from .file_reader import *
 from .invocable import *
-from .invoke_args import *
 from .invoker import *
 from .invoker_client import *
-from .options import *
 from .uri import *
-from .uri_like import *
 from .uri_package import *
 from .uri_package_wrapper import *
 from .uri_resolution_context import *

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

@@ -1,83 +1,84 @@
 """This module contains the Client interface."""
 from __future__ import annotations
 
-from abc import abstractmethod
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Protocol, Union
 
-from polywrap_manifest import AnyWrapManifest
+from polywrap_manifest import AnyWrapManifest, DeserializeManifestOptions
 
-from .env import Env
 from .invoker_client import InvokerClient
-from .options.file_options import GetFileOptions
-from .options.manifest_options import GetManifestOptions
 from .uri import Uri
-from .uri_package_wrapper import UriPackageOrWrapper
 from .uri_resolver import UriResolver
 
 
-class Client(InvokerClient[UriPackageOrWrapper]):
+class Client(InvokerClient, Protocol):
     """Client interface defines core set of functionalities\
         for interacting with a wrapper."""
 
-    @abstractmethod
     def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         """Get dictionary of interfaces and their implementations.
 
         Returns:
             Dict[Uri, List[Uri]]: Dictionary of interfaces and their implementations where\
                 key is interface URI and value is list of implementation uris.
         """
+        ...
 
-    @abstractmethod
-    def get_envs(self) -> Dict[Uri, Env]:
+    def get_envs(self) -> Dict[Uri, Any]:
         """Get dictionary of environments.
 
         Returns:
-            Dict[Uri, Env]: Dictionary of environments where key is URI and value is env.
+            Dict[Uri, Any]: Dictionary of environments where key is URI and value is env.
         """
+        ...
 
-    @abstractmethod
-    def get_env_by_uri(self, uri: Uri) -> Union[Env, None]:
+    def get_env_by_uri(self, uri: Uri) -> Union[Any, None]:
         """Get environment by URI.
 
         Args:
             uri (Uri): URI of the Wrapper.
 
         Returns:
-            Union[Env, None]: env if found, otherwise None.
+            Union[Any, None]: env if found, otherwise None.
         """
+        ...
 
-    @abstractmethod
     def get_uri_resolver(self) -> UriResolver:
         """Get URI resolver.
 
         Returns:
-            IUriResolver: URI resolver.
+            UriResolver: URI resolver.
         """
+        ...
 
-    @abstractmethod
-    async def get_file(self, uri: Uri, options: GetFileOptions) -> Union[bytes, str]:
+    def get_file(
+        self, uri: Uri, path: str, encoding: Optional[str] = "utf-8"
+    ) -> Union[bytes, str]:
         """Get file from URI.
 
         Args:
             uri (Uri): URI of the wrapper.
-            options (GetFileOptions): Options for getting file from the wrapper.
+            path (str): Path to the file.
+            encoding (Optional[str]): Encoding of the file.
 
         Returns:
             Union[bytes, str]]: file contents.
         """
+        ...
 
-    @abstractmethod
-    async def get_manifest(
-        self, uri: Uri, options: Optional[GetManifestOptions] = None
+    def get_manifest(
+        self, uri: Uri, options: Optional[DeserializeManifestOptions] = None
     ) -> AnyWrapManifest:
         """Get manifest from URI.
 
         Args:
             uri (Uri): URI of the wrapper.
-            options (Optional[GetManifestOptions]): \
+            options (Optional[DeserializeManifestOptions]): \
                 Options for getting manifest from the wrapper.
 
         Returns:
             AnyWrapManifest: Manifest of the wrapper.
         """
+        ...
+
+
+__all__ = ["Client"]

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

@@ -2,9 +2,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Dict, List
+from typing import Any, Dict, List
 
-from .env import Env
 from .uri import Uri
 from .uri_resolver import UriResolver
 
@@ -14,14 +13,17 @@ class ClientConfig:
     """Client configuration.
 
     Attributes:
-        envs (Dict[Uri, Env]): Dictionary of environments \
+        envs (Dict[Uri, Any]): Dictionary of environments \
             where key is URI and value is env.
         interfaces (Dict[Uri, List[Uri]]): Dictionary of interfaces \
             and their implementations where key is interface URI \
             and value is list of implementation URIs.
         resolver (UriResolver): URI resolver.
     """
 
-    envs: Dict[Uri, Env] = field(default_factory=dict)
+    envs: Dict[Uri, Any] = field(default_factory=dict)
     interfaces: Dict[Uri, List[Uri]] = field(default_factory=dict)
     resolver: UriResolver
+
+
+__all__ = ["ClientConfig"]