digitalkin 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

digitalkin/services/filesystem/filesystem_strategy.py

@@ -1,31 +1,70 @@
 """This module contains the abstract base class for filesystem strategies."""
 
 from abc import ABC, abstractmethod
-from typing import Any
+from enum import Enum, auto
 
+from pydantic import BaseModel, Field
 
-class FilesystemStrategy(ABC):
-    """Abstract base class for file system strategies."""
+from digitalkin.services.base_strategy import BaseStrategy
 
-    def __init__(self) -> None:
-        """Initialize the file system strategy."""
+
+class FilesystemServiceError(Exception):
+    """Base exception for Setup service errors."""
+
+
+class FileType(Enum):
+    """Enum defining the types of data that can be stored."""
+
+    DOCUMENT = auto()
+    IMAGE = auto()
+    VIDEO = auto()
+    AUDIO = auto()
+    ARCHIVE = auto()
+    OTHER = auto()
+
+
+class FilesystemData(BaseModel):
+    """Data model for filesystem operations."""
+
+    kin_context: str = Field(description="The context of the file in the filesystem")
+    name: str = Field(description="The name of the file")
+    file_type: FileType = Field(default=FileType.DOCUMENT, description="The type of data stored")
+    url: str = Field(description="The URL of the file in the filesystem")
+
+
+class FilesystemStrategy(BaseStrategy, ABC):
+    """Abstract base class for filesystem strategies."""
+
+    def __init__(self, mission_id: str, config: dict[str, str]) -> None:
+        """Initialize the strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            config: configuration dictionary for the filesystem strategy
+        """
+        super().__init__(mission_id)
+        self.config: dict[str, str] = config
+
+    @abstractmethod
+    def upload(self, content: bytes, name: str, file_type: FileType) -> FilesystemData:
+        """Create a new file in the filesystem."""
 
     @abstractmethod
-    def create(self, data: dict[str, Any]) -> str:
-        """Create a new file in the file system."""
+    def get(self, name: str) -> FilesystemData:
+        """Get file from the filesystem."""
 
     @abstractmethod
-    def get(self, data: dict[str, Any]) -> list[dict[str, Any]]:
-        """Get files from the file system."""
+    def get_batch(self, names: list[str]) -> dict[str, FilesystemData | None]:
+        """Get files from the filesystem."""
 
     @abstractmethod
-    def update(self, data: dict[str, Any]) -> int:
-        """Update files in the file system."""
+    def get_all(self) -> list[FilesystemData]:
+        """Get all files from the filesystem."""
 
     @abstractmethod
-    def delete(self, data: dict[str, Any]) -> int:
-        """Delete files from the file system."""
+    def update(self, name: str, content: bytes, file_type: FileType) -> FilesystemData:
+        """Update files in the filesystem."""
 
     @abstractmethod
-    def get_all(self) -> list[dict[str, Any]]:
-        """Get all files from the file system."""
+    def delete(self, name: str) -> bool:
+        """Delete file from the filesystem."""

digitalkin/services/filesystem/grpc_filesystem.py

@@ -0,0 +1,209 @@
+"""Grpc filesystem."""
+
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+from digitalkin_proto.digitalkin.filesystem.v2 import filesystem_pb2, filesystem_service_pb2_grpc
+from digitalkin_proto.digitalkin.filesystem.v2.filesystem_pb2 import FileType as FileTypeProto
+
+from digitalkin.grpc_servers.utils.exceptions import ServerError
+from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
+from digitalkin.grpc_servers.utils.models import ServerConfig
+from digitalkin.services.filesystem.filesystem_strategy import (
+    FilesystemData,
+    FilesystemServiceError,
+    FilesystemStrategy,
+    FileType,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
+    """Default state filesystem strategy."""
+
+    def __init__(
+        self,
+        mission_id: str,
+        config: dict[str, str],
+        server_config: ServerConfig,
+        **kwargs,  # noqa: ANN003, ARG002
+    ) -> None:
+        """Initialize the default filesystem strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            config: A dictionary mapping names to Pydantic model classes
+            server_config: The server configuration object
+            kwargs: other optional arguments to pass to the parent class constructor
+        """
+        super().__init__(mission_id, config)
+        channel = self._init_channel(server_config)
+        self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
+        logger.info("Channel client 'Filesystem' initialized succesfully")
+
+    @staticmethod
+    @contextmanager
+    def _handle_grpc_errors(operation: str) -> Generator[Any, Any, Any]:
+        """Context manager for consistent gRPC error handling.
+
+        Yields:
+            Allow error handling in context.
+
+        Args:
+            operation: Description of the operation being performed.
+
+        Raises:
+            ValueError: Error wiht the model validation.
+            ServerError: from gRPC Client.
+            FilesystemServiceError: Filesystem service internal.
+        """
+        try:
+            yield
+        except ServerError as e:
+            msg = f"gRPC {operation} failed: {e}"
+            logger.exception(msg)
+            raise ServerError(msg) from e
+        except Exception as e:
+            msg = f"Unexpected error in {operation}"
+            logger.exception(msg)
+            raise FilesystemServiceError(msg) from e
+
+    def upload(self, content: bytes, name: str, file_type: FileType) -> FilesystemData:
+        """Create a new file in the file system.
+
+        Args:
+            content: The content of the file to be uploaded
+            name: The name of the file to be created
+            file_type: The type of data being uploaded
+
+        Returns:
+            FilesystemData: Metadata about the uploaded file
+
+        Raises:
+            ValueError: If the file already exists
+        """
+        with GrpcFilesystem._handle_grpc_errors("UploadFile"):
+            request = filesystem_pb2.UploadFileRequest(
+                kin_context=self.mission_id,
+                name=name,
+                file_type=file_type.name,
+                content=content,
+            )
+            response: filesystem_pb2.UploadFileResponse = self.exec_grpc_query("UploadFile", request)
+            return FilesystemData(
+                kin_context=response.file.kin_context,
+                name=response.file.name,
+                file_type=FileType[FileTypeProto.Name(response.file.file_type)],
+                url=response.file.url,
+            )
+
+    def get(self, name: str) -> FilesystemData:
+        """Get file from the filesystem.
+
+        Args:
+            name: The name of the file to be retrieved
+
+        Returns:
+            FilesystemData: Metadata about the retrieved file
+        """
+        with GrpcFilesystem._handle_grpc_errors("GetFileByName"):
+            request = filesystem_pb2.GetFileByNameRequest(name=name)
+            response: filesystem_pb2.GetFileByNameResponse = self.exec_grpc_query("GetFileByName", request)
+            return FilesystemData(
+                kin_context=response.file.kin_context,
+                name=response.file.name,
+                file_type=FileType[FileTypeProto.Name(response.file.file_type)],
+                url=response.file.url,
+            )
+
+    def update(self, name: str, content: bytes, file_type: FileType) -> FilesystemData:
+        """Update files in the filesystem.
+
+        Args:
+            name: The name of the file to be updated
+            content: The new content of the file
+            file_type: The type of data being uploaded
+
+        Returns:
+            FilesystemData: Metadata about the updated file
+        """
+        with GrpcFilesystem._handle_grpc_errors("UpdateFile"):
+            request = filesystem_pb2.UpdateFileRequest(
+                kin_context=self.mission_id,
+                name=name,
+                file_type=file_type.name,
+                content=content,
+            )
+            response: filesystem_pb2.UpdateFileResponse = self.exec_grpc_query("UpdateFile", request)
+            return FilesystemData(
+                kin_context=response.file.kin_context,
+                name=response.file.name,
+                file_type=FileType[FileTypeProto.Name(response.file.file_type)],
+                url=response.file.url,
+            )
+
+    def delete(self, name: str) -> bool:
+        """Delete files from the filesystem.
+
+        Args:
+            name: The name of the file to be deleted
+
+        Returns:
+            int: 1 if the file was deleted successfully, 0 if it didn't exist, None on error
+        """
+        with GrpcFilesystem._handle_grpc_errors("DeleteFile"):
+            request = filesystem_pb2.DeleteFileRequest(name=name)
+            _: filesystem_pb2.DeleteFileResponse = self.exec_grpc_query("DeleteFile", request)
+            return True
+
+    def get_all(self) -> list[FilesystemData]:
+        """Get all files from the filesystem.
+
+        Returns:
+            list[FilesystemData]: A list of all files in the filesystem
+        """
+        with GrpcFilesystem._handle_grpc_errors("GetFilesByKinContext"):
+            request = filesystem_pb2.GetFilesByKinContextRequest(kin_context=self.mission_id)
+            response: filesystem_pb2.GetFilesByKinContextResponse = self.exec_grpc_query(
+                "GetFilesByKinContext", request
+            )
+            return [
+                FilesystemData(
+                    kin_context=file.kin_context,
+                    name=file.name,
+                    file_type=FileType[FileTypeProto.Name(file.file_type)],
+                    url=file.url,
+                )
+                for file in response.files
+            ]
+
+    def get_batch(self, names: list[str]) -> dict[str, FilesystemData | None]:
+        """Get files from the filesystem.
+
+        Args:
+            names: The names of the files to be retrieved
+
+        Returns:
+            list[FilesystemData]: A list of metadata about the retrieved files
+        """
+        with GrpcFilesystem._handle_grpc_errors("GetFilesByNames"):
+            request = filesystem_pb2.GetFilesByNamesRequest(names=names)
+            response: filesystem_pb2.GetFilesByNamesResponse = self.exec_grpc_query("GetFilesByNames", request)
+            result: dict[str, FilesystemData | None] = {}
+            for name, file_result in response.files.items():
+                which_field = file_result.WhichOneof("result")
+                if which_field == "file":
+                    result[name] = FilesystemData(
+                        kin_context=file_result.file.kin_context,
+                        name=file_result.file.name,
+                        file_type=FileType[FileTypeProto.Name(file_result.file.file_type)],
+                        url=file_result.file.url,
+                    )
+                elif which_field == "error":
+                    # Handle error case
+                    result[name] = None
+                    logger.warning("Error retrieving file '%s': %s", name, file_result.error)
+            return result

digitalkin/services/identity/__init__.py

@@ -1,6 +1,6 @@
 """This module is responsible for handling the identity service."""
 
-from .default_identity import DefaultIdentity
-from .identity_strategy import IdentityStrategy
+from digitalkin.services.identity.default_identity import DefaultIdentity
+from digitalkin.services.identity.identity_strategy import IdentityStrategy
 
 __all__ = ["DefaultIdentity", "IdentityStrategy"]

digitalkin/services/identity/default_identity.py

@@ -1,6 +1,6 @@
 """Default identity."""
 
-from .identity_strategy import IdentityStrategy
+from digitalkin.services.identity.identity_strategy import IdentityStrategy
 
 
 class DefaultIdentity(IdentityStrategy):

digitalkin/services/identity/identity_strategy.py

@@ -2,8 +2,10 @@
 
 from abc import ABC, abstractmethod
 
+from digitalkin.services.base_strategy import BaseStrategy
 
-class IdentityStrategy(ABC):
+
+class IdentityStrategy(BaseStrategy, ABC):
     """IdentityStrategy is the abstract base class for all identity strategies."""
 
     @abstractmethod

digitalkin/services/registry/__init__.py

@@ -1,6 +1,6 @@
 """This module is responsible for handling the registry service."""
 
-from .default_registry import DefaultRegistry
-from .registry_strategy import RegistryStrategy
+from digitalkin.services.registry.default_registry import DefaultRegistry
+from digitalkin.services.registry.registry_strategy import RegistryStrategy
 
 __all__ = ["DefaultRegistry", "RegistryStrategy"]

digitalkin/services/registry/default_registry.py

@@ -1,13 +1,10 @@
 """Default registry."""
 
-from .registry_strategy import RegistryStrategy
+from digitalkin.services.registry.registry_strategy import RegistryStrategy
 
 
 class DefaultRegistry(RegistryStrategy):
     """Default registry strategy."""
 
-    def __init__(self) -> None:
-        """Initialize the registry strategy."""
-
     def get_by_id(self, module_id: str) -> None:
         """Get services from the registry."""

digitalkin/services/registry/registry_strategy.py

@@ -2,14 +2,11 @@
 
 from abc import ABC, abstractmethod
 
+from digitalkin.services.base_strategy import BaseStrategy
 
-class RegistryStrategy(ABC):
-    """Abstract base class for registry strategies."""
 
-    @abstractmethod
-    def __init__(self) -> None:
-        """Initialize the registry strategy."""
-        raise NotImplementedError
+class RegistryStrategy(BaseStrategy, ABC):
+    """Abstract base class for registry strategies."""
 
     @abstractmethod
     def get_by_id(self, module_id: str) -> None:

digitalkin/services/services_config.py

@@ -0,0 +1,176 @@
+"""Service Provider definitions."""
+
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field, PrivateAttr
+
+from digitalkin.services.agent import AgentStrategy, DefaultAgent
+from digitalkin.services.cost import CostStrategy, DefaultCost
+from digitalkin.services.filesystem import DefaultFilesystem, FilesystemStrategy, GrpcFilesystem
+from digitalkin.services.identity import DefaultIdentity, IdentityStrategy
+from digitalkin.services.registry import DefaultRegistry, RegistryStrategy
+from digitalkin.services.services_models import ServicesMode, ServicesStrategy
+from digitalkin.services.snapshot import DefaultSnapshot, SnapshotStrategy
+from digitalkin.services.storage import DefaultStorage, GrpcStorage, StorageStrategy
+
+
+class ServicesConfig(BaseModel):
+    """Service class describing the available services in a Module.
+
+    This class manages the strategy implementations for various services,
+    allowing them to be switched between local and remote modes.
+    """
+
+    # Mode setting for all strategies
+    mode: ServicesMode = Field(default=ServicesMode.LOCAL, description="The mode of the services (local or remote)")
+
+    # Strategy definitions with proper type annotations
+    _storage: ServicesStrategy[StorageStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultStorage, remote=GrpcStorage)
+    )
+    _config_storage: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _cost: ServicesStrategy[CostStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultCost, remote=DefaultCost)
+    )
+    _config_cost: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _snapshot: ServicesStrategy[SnapshotStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultSnapshot, remote=DefaultSnapshot)
+    )
+    _config_snapshot: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _registry: ServicesStrategy[RegistryStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultRegistry, remote=DefaultRegistry)
+    )
+    _config__registry: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _filesystem: ServicesStrategy[FilesystemStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultFilesystem, remote=GrpcFilesystem)
+    )
+    _config_filesystem: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _agent: ServicesStrategy[AgentStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultAgent, remote=DefaultAgent)
+    )
+    _config_agent: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _identity: ServicesStrategy[IdentityStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultIdentity, remote=DefaultIdentity)
+    )
+    _config_identity: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+
+    # List of valid strategy names for validation
+    _valid_strategy_names: ClassVar[set[str]] = {
+        "storage",
+        "cost",
+        "snapshot",
+        "registry",
+        "filesystem",
+        "agent",
+        "identity",
+    }
+
+    def __init__(
+        self,
+        services_config_strategies: dict[str, ServicesStrategy | None] = {},
+        services_config_params: dict[str, dict[str, Any | None] | None] = {},
+        mode: ServicesMode = ServicesMode.LOCAL,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        """Initialize the service configuration with optional strategy overrides.
+
+        Args:
+            services_config_strategies: Dictionary mapping service names to strategy implementations
+            services_config_params: Dictionary mapping service names to configuration parameters
+            mode: The mode of the services (local or remote)
+            **kwargs: Additional keyword arguments passed to the parent class constructor
+        """
+        super().__init__(**kwargs)
+        self.mode = mode
+        # Apply any strategy overrides
+        if services_config_strategies:
+            for name, strategy in services_config_strategies.items():
+                if strategy is not None and name in self._valid_strategy_names:
+                    setattr(self, f"_{name}", strategy)
+
+        for name in self.valid_strategy_names():
+            setattr(self, f"_config_{name}", services_config_params.get(name, {}))
+
+    @classmethod
+    def valid_strategy_names(cls) -> set[str]:
+        """Get the list of valid strategy names.
+
+        Returns:
+            The set of valid strategy names.
+        """
+        return cls._valid_strategy_names
+
+    def get_strategy_config(self, name: str) -> dict[str, Any]:
+        """Get the configuration for a specific strategy.
+
+        Args:
+            name: The name of the strategy to retrieve the configuration for
+
+        Returns:
+            The configuration for the specified strategy, or None if not found
+        """
+        return getattr(self, f"_config_{name}", {})
+
+    def init_strategy(self, name: str, mission_id: str) -> ServicesStrategy:
+        """Initialize a specific strategy.
+
+        Args:
+            name: The name of the strategy to initialize
+            mission_id: The ID of the mission this strategy is associated with
+
+        Returns:
+            The initialized strategy instance
+
+        Raises:
+            ValueError: If the strategy is not found
+        """
+        strategy_type = getattr(self, name, None)
+        if strategy_type is None:
+            msg = f"Strategy {name} not found in ServicesConfig."
+            raise ValueError(msg)
+
+        # Instantiate the strategy with the mission ID and configuration
+        return strategy_type(mission_id, **self.get_strategy_config(name) or {})
+
+    @property
+    def storage(self) -> type[StorageStrategy]:
+        """Get the storage service strategy class based on the current mode."""
+        return self._storage[self.mode.value]
+
+    @property
+    def cost(self) -> type[CostStrategy]:
+        """Get the cost service strategy class based on the current mode."""
+        return self._cost[self.mode.value]
+
+    @property
+    def snapshot(self) -> type[SnapshotStrategy]:
+        """Get the snapshot service strategy class based on the current mode."""
+        return self._snapshot[self.mode.value]
+
+    @property
+    def registry(self) -> type[RegistryStrategy]:
+        """Get the registry service strategy class based on the current mode."""
+        return self._registry[self.mode.value]
+
+    @property
+    def filesystem(self) -> type[FilesystemStrategy]:
+        """Get the filesystem service strategy class based on the current mode."""
+        return self._filesystem[self.mode.value]
+
+    @property
+    def agent(self) -> type[AgentStrategy]:
+        """Get the agent service strategy class based on the current mode."""
+        return self._agent[self.mode.value]
+
+    @property
+    def identity(self) -> type[IdentityStrategy]:
+        """Get the identity service strategy class based on the current mode."""
+        return self._identity[self.mode.value]
+
+    def update_mode(self, mode: ServicesMode) -> None:
+        """Update the strategy mode.
+
+        Parameters:
+            mode: The new mode to use for all strategies
+        """
+        self.mode = mode

digitalkin/services/services_models.py

@@ -0,0 +1,61 @@
+"""This module contains the strategy models for the services."""
+
+from enum import Enum
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+from digitalkin.logger import logger
+from digitalkin.services.agent import AgentStrategy
+from digitalkin.services.cost import CostStrategy
+from digitalkin.services.filesystem import FilesystemStrategy
+from digitalkin.services.identity import IdentityStrategy
+from digitalkin.services.registry import RegistryStrategy
+from digitalkin.services.snapshot import SnapshotStrategy
+from digitalkin.services.storage import StorageStrategy
+
+# Define type variables
+T = TypeVar(
+    "T",
+    bound=AgentStrategy
+    | CostStrategy
+    | FilesystemStrategy
+    | IdentityStrategy
+    | RegistryStrategy
+    | SnapshotStrategy
+    | StorageStrategy,
+)
+
+
+class ServicesMode(str, Enum):
+    """Mode for strategy execution."""
+
+    LOCAL = "local"
+    REMOTE = "remote"
+
+
+class ServicesStrategy(BaseModel, Generic[T]):
+    """Service class describing the available services in a Module with local and remote attributes.
+
+    Attributes:
+        local: type
+        remote: type
+    """
+
+    local: type[T]
+    remote: type[T]
+
+    def __getitem__(self, mode: str) -> type[T]:
+        """Get the service strategy based on the mode.
+
+        Args:
+            mode (str): The mode to get the strategy for.
+
+        Returns:
+            The strategy based on the mode.
+        """
+        try:
+            return getattr(self, mode)
+        except AttributeError:
+            logger.exception("Unknown mode: %s, available modes are: %s", mode, ServicesMode.__members__)
+            return getattr(self, ServicesMode.LOCAL.value)