mantatech-sdk 0.5b0.dev65__py3-none-any.whl

manta/clients/local_client.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from logging import getLogger
+from typing import AsyncIterator, Optional, Type, TypeVar
+
+from manta_common.base_client import GrpcClientBase
+from manta_common.build.common.system import Binary
+from manta_common.build.node.light_service import (
+    DataRequest,
+    DirRequest,
+    ExistsResponse,
+    ListDirResponse,
+    LocalStub,
+    ReadText,
+)
+from manta_common.retry import RetryPolicy, StreamingRetryPolicy
+
+__all__ = ["LocalClient"]
+
+T = TypeVar("T")
+
+
+class LocalClient(GrpcClientBase):
+    """
+    Local client facilitates access to the local (Node) data with retry
+    and connection management capabilities.
+    """
+
+    __slots__ = ()
+
+    #: Default retry policy for regular methods
+    DEFAULT_RETRY_POLICY = RetryPolicy(
+        max_retries=3,
+        initial_delay=0.2,
+        max_delay=10.0,
+        backoff_factor=2.0,
+        jitter_factor=0.2,
+    )
+
+    #: Default retry policy for streaming methods
+    DEFAULT_STREAMING_RETRY_POLICY = StreamingRetryPolicy(
+        max_retries=3,
+        initial_delay=0.2,
+        max_delay=10.0,
+        backoff_factor=2.0,
+        jitter_factor=0.2,
+        retry_if_no_items_processed=True,
+    )
+
+    def _get_stub_class(self) -> Type[LocalStub]:
+        """
+        Get the stub class for this client.
+        """
+        return LocalStub
+
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 50051,
+        retry_policy: Optional[RetryPolicy] = None,
+        streaming_retry_policy: Optional[StreamingRetryPolicy] = None,
+    ) -> None:
+        """
+        Initialize Local client
+
+        Parameters
+        ----------
+        host : str
+            Node hostname
+        port : int
+            Node port
+        retry_policy : Optional[RetryPolicy]
+            Custom retry policy for operations
+        streaming_retry_policy : Optional[StreamingRetryPolicy]
+            Custom retry policy for streaming operations
+        """
+        super().__init__(
+            host=host,
+            port=port,
+            retry_policy=retry_policy,
+            streaming_retry_policy=streaming_retry_policy,
+            tracer=getLogger(__name__),
+        )
+
+    async def get_binary_data(self, request: DataRequest) -> AsyncIterator[Binary]:
+        """
+        Get binary data from the node.
+
+        Parameters
+        ----------
+        request : DataRequest
+            Request containing task_id, swarm_id, and name
+
+        Returns
+        -------
+        AsyncIterator[Binary]
+            Stream of binary data chunks
+        """
+        async for chunk in self.stream_service_method("get_binary_data", request):
+            yield chunk
+
+    async def list_dir(self, request: DirRequest) -> ListDirResponse:
+        """
+        List directory contents on the node.
+
+        Parameters
+        ----------
+        request : DirRequest
+            Directory request containing data_request and path
+
+        Returns
+        -------
+        ListDirResponse
+            Response containing list of paths
+        """
+        return await self.call_service_method("list_dir", request)
+
+    async def read_file_lines(self, request: ReadText) -> AsyncIterator[Binary]:
+        """
+        Read file lines from the node.
+
+        Parameters
+        ----------
+        request : ReadText
+            Request containing data_request, path, encoding, errors, and newline
+
+        Returns
+        -------
+        AsyncIterator[Binary]
+            Stream of file lines as binary chunks
+        """
+        async for chunk in self.stream_service_method("read_file_lines", request):
+            yield chunk
+
+    async def exists(self, request: DirRequest) -> ExistsResponse:
+        """
+        Check if a file or directory exists on the node.
+
+        Parameters
+        ----------
+        request : DirRequest
+            Directory request containing data_request and path
+
+        Returns
+        -------
+        ExistsResponse
+            Response indicating whether the path exists
+        """
+        return await self.call_service_method("exists", request)

manta/clients/module_management_client.py

@@ -0,0 +1,217 @@
+"""
+Module Management Client implementation.
+
+This module provides the ModuleManagementClient class for interacting with the ModuleManagement service.
+"""
+
+from __future__ import annotations
+
+from logging import Logger
+from pathlib import Path
+from typing import Any, AsyncIterator, Dict, Optional, Type, TypeVar
+
+from manta_common.base_client import GrpcClientBase, MetadataDict
+from manta_common.build.common.system import CollectionIds, Empty, Response, StrId
+from manta_common.build.common.tasks import Module
+from manta_common.build.core.user_services import (  # Request/Response messages; Service stub
+    ModuleManagementStub,
+    ModuleRequest,
+)
+from manta_common.retry import RetryPolicy
+
+T = TypeVar("T")
+
+
+class ModuleManagementClient(GrpcClientBase):
+    """
+    Client for interacting with the ModuleManagement Service.
+
+    This client provides a high-level interface for making gRPC calls to the ModuleManagement service,
+    handling module management and versioning operations.
+    """
+
+    __slots__ = ("_secure", "cafile", "certfile", "keyfile")
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        jwt_token: str,
+        secure: bool = False,
+        cafile: Optional[str] = None,
+        certfile: Optional[str] = None,
+        keyfile: Optional[str] = None,
+        channel_options: Optional[Dict[str, Any]] = None,
+        logger: Optional[Logger] = None,
+        retry_policy: Optional[RetryPolicy] = None,
+        streaming_retry_policy: Optional[RetryPolicy] = None,
+    ):
+        """
+        Initialize the ModuleManagementClient.
+
+        Parameters
+        ----------
+        host : str
+            The host of the ModuleManagement service
+        port : int
+            The port of the ModuleManagement service
+        jwt_token : str
+            JWT token for authentication
+        secure : bool
+            Whether to use a secure connection
+        cafile : Optional[str]
+            Path to the CA certificate file for verifying the server
+        certfile : Optional[str]
+            Path to the client certificate file
+        keyfile : Optional[str]
+            Path to the client private key file
+        channel_options : Optional[Dict[str, Any]]
+            The channel options
+        logger : Optional[Logger]
+            The logger
+        retry_policy : Optional[RetryPolicy]
+            The retry policy
+        streaming_retry_policy : Optional[RetryPolicy]
+            The streaming retry policy
+        """
+        super().__init__(
+            host=host,
+            port=port,
+            secure=secure,
+            channel_options=channel_options,
+            tracer=logger,
+            retry_policy=retry_policy,
+            streaming_retry_policy=streaming_retry_policy,
+        )
+        self.jwt_token = jwt_token
+        self._secure = secure
+        self.cafile = Path(cafile) if cafile is not None else None
+        self.certfile = Path(certfile) if certfile is not None else None
+        self.keyfile = Path(keyfile) if keyfile is not None else None
+
+    @property
+    def metadata(self) -> MetadataDict:
+        return {"authorization": self.jwt_token}
+
+    def _get_stub_class(self) -> Type[ModuleManagementStub]:
+        """Get the stub class for the ModuleManagement service."""
+        return ModuleManagementStub
+
+    async def is_available(self) -> Response:
+        """
+        Check if the ModuleManagement service is available.
+
+        Returns
+        -------
+        Response
+            Service availability status
+        """
+        return await self.call_service_method(
+            "is_available",
+            Empty(),
+        )
+
+    async def send_module(self, module: Module) -> StrId:
+        """
+        Send/create a new module.
+
+        Parameters
+        ----------
+        module : Module
+            Module to create
+
+        Returns
+        -------
+        StrId
+            Module ID
+        """
+        return await self.call_service_method(
+            "send_module",
+            module,
+        )
+
+    async def list_module_ids(self) -> CollectionIds:
+        """
+        List all module IDs for the authenticated user.
+
+        Returns
+        -------
+        CollectionIds
+            Collection of module IDs
+        """
+        return await self.call_service_method(
+            "list_module_ids",
+            Empty(),
+        )
+
+    async def stream_modules(self) -> AsyncIterator[ModuleRequest]:
+        """
+        Stream all modules for the authenticated user.
+
+        Yields
+        ------
+        ModuleRequest
+            Module details wrapped in ModuleRequest
+        """
+        async for module_request in self.stream_service_method(
+            "stream_modules",
+            Empty(),
+        ):
+            yield module_request
+
+    async def get_module(self, module_id: str) -> ModuleRequest:
+        """
+        Get a module by its ID.
+
+        Parameters
+        ----------
+        module_id : str
+            ID of the module
+
+        Returns
+        -------
+        ModuleRequest
+            Module details wrapped in ModuleRequest
+        """
+        return await self.call_service_method(
+            "get_module",
+            StrId(id=module_id),
+        )
+
+    async def update_module(self, module_request: ModuleRequest) -> StrId:
+        """
+        Update an existing module.
+
+        Parameters
+        ----------
+        module_request : ModuleRequest
+            Module request containing module data and module_id
+
+        Returns
+        -------
+        StrId
+            Module ID
+        """
+        return await self.call_service_method(
+            "update_module",
+            module_request,
+        )
+
+    async def remove_module(self, module_id: str) -> Response:
+        """
+        Remove a module from the system.
+
+        Parameters
+        ----------
+        module_id : str
+            ID of the module to remove
+
+        Returns
+        -------
+        Response
+            Removal confirmation response
+        """
+        return await self.call_service_method(
+            "remove_module",
+            StrId(id=module_id),
+        )