digitalkin 0.3.2.dev2__py3-none-any.whl

digitalkin/services/services_models.py

@@ -0,0 +1,65 @@
+"""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.communication import CommunicationStrategy
+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
+from digitalkin.services.user_profile import UserProfileStrategy
+
+# Define type variables
+T = TypeVar(
+    "T",
+    bound=AgentStrategy
+    | CommunicationStrategy
+    | CostStrategy
+    | FilesystemStrategy
+    | IdentityStrategy
+    | RegistryStrategy
+    | SnapshotStrategy
+    | StorageStrategy
+    | UserProfileStrategy,
+)
+
+
+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)

digitalkin/services/setup/__init__.py

@@ -0,0 +1 @@
+"""This module is responsible for handling the setup service."""

digitalkin/services/setup/default_setup.py

@@ -0,0 +1,219 @@
+"""This module contains the abstract base class for setup strategies."""
+
+import secrets
+import string
+from typing import Any
+
+from pydantic import ValidationError
+
+from digitalkin.logger import logger
+from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
+
+
+class DefaultSetup(SetupStrategy):
+    """Abstract base class for setup strategies."""
+
+    setups: dict[str, SetupData]
+    setup_versions: dict[str, dict[str, SetupVersionData]]
+
+    def __init__(self) -> None:
+        """Initialize the default setup strategy."""
+        super().__init__()
+        self.setups = {}
+        self.setup_versions = {}
+
+    def create_setup(self, setup_dict: dict[str, Any]) -> str:
+        """Create a new setup with comprehensive validation.
+
+        Args:
+            setup_dict: Dictionary containing setup details.
+
+        Returns:
+            bool: Success status of setup creation.
+
+        Raises:
+            ValidationError: If setup data is invalid.
+            GrpcOperationError: If gRPC operation fails.
+        """
+        try:
+            valid_data = SetupData.model_validate(setup_dict["data"])  # Revalidates instance
+        except ValidationError:
+            logger.exception("Validation failed for model SetupData")
+            return ""
+
+        setup_id = setup_dict.get(
+            "setup_id", "".join(secrets.choice(string.ascii_letters + string.digits) for _ in range(16))
+        )
+        valid_data.id = setup_id
+        self.setups[setup_id] = valid_data
+        logger.debug("CREATE SETUP DATA %s:%s successful", setup_id, valid_data)
+        return setup_id
+
+    def get_setup(self, setup_dict: dict[str, Any]) -> SetupData:
+        """Retrieve a setup by its unique identifier.
+
+        Args:
+            setup_dict: Dictionary with 'name' and optional 'version'.
+
+        Raises:
+            SetupServiceError: setup_id does not exist.
+
+        Returns:
+            Dict[str, Any]: Setup details including optional setup version.
+        """
+        logger.debug("GET setup_id = %s", setup_dict["setup_id"])
+        if setup_dict["setup_id"] not in self.setups:
+            msg = f"GET setup_id = {setup_dict['setup_id']}: setup_id DOESN'T EXIST"
+            logger.error(msg)
+            raise SetupServiceError(msg)
+        return self.setups[setup_dict["setup_id"]]
+
+    def update_setup(self, setup_dict: dict[str, Any]) -> bool:
+        """Update an existing setup.
+
+        Args:
+            setup_dict: Dictionary with setup update details.
+
+        Raises:
+            ValidationError: setup object failed validation.
+
+        Returns:
+            bool: Success status of the update operation.
+        """
+        if setup_dict["setup_id"] not in self.setups:
+            logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_dict["setup_id"])
+            return False
+
+        try:
+            valid_data = SetupData.model_validate(setup_dict["data"])  # Revalidates instance
+        except ValidationError:
+            logger.exception("Validation failed for model SetupData")
+            return False
+
+        self.setups[setup_dict["update_id"]] = valid_data
+        return True
+
+    def delete_setup(self, setup_dict: dict[str, Any]) -> bool:
+        """Delete a setup by its unique identifier.
+
+        Args:
+            setup_dict: Dictionary with the setup 'name'.
+
+        Returns:
+            bool: Success status of deletion.
+        """
+        if setup_dict["setup_id"] not in self.setups:
+            logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_dict["setup_id"])
+            return False
+        del self.setups[setup_dict["setup_id"]]
+        return True
+
+    def create_setup_version(self, setup_version_dict: dict[str, Any]) -> str:
+        """Create a new setup version.
+
+        Args:
+            setup_version_dict: Dictionary with setup version details.
+
+        Raises:
+            SetupServiceError: setup object failed validation.
+
+        Returns:
+            str: version of setup version creation.
+        """
+        try:
+            valid_data = SetupVersionData.model_validate(setup_version_dict["data"])  # Revalidates instance
+        except ValidationError:
+            msg = "Validation failed for model SetupVersionData"
+            logger.exception(msg)
+            raise SetupServiceError(msg)
+
+        if setup_version_dict["setup_id"] not in self.setup_versions:
+            self.setup_versions[setup_version_dict["setup_id"]] = {}
+        self.setup_versions[setup_version_dict["setup_id"]][valid_data.version] = valid_data
+        logger.debug("CREATE SETUP VERSION DATA %s:%s successful", setup_version_dict["setup_id"], valid_data)
+        return valid_data.version
+
+    def get_setup_version(self, setup_version_dict: dict[str, Any]) -> SetupVersionData:
+        """Retrieve a setup version by its unique identifier.
+
+        Args:
+            setup_version_dict: Dictionary with the setup version 'name'.
+
+        Raises:
+            SetupServiceError: setup_id does not exist.
+
+        Returns:
+            Dict[str, Any]: Setup version details.
+        """
+        logger.debug("GET setup_id = %s: version = %s", setup_version_dict["setup_id"], setup_version_dict["version"])
+        if setup_version_dict["setup_id"] not in self.setup_versions:
+            msg = f"GET setup_id = {setup_version_dict['setup_id']}: setup_id DOESN'T EXIST"
+            logger.error(msg)
+            raise SetupServiceError(msg)
+
+        return self.setup_versions[setup_version_dict["setup_id"]][setup_version_dict["version"]]
+
+    def search_setup_versions(self, setup_version_dict: dict[str, Any]) -> list[SetupVersionData]:
+        """Search for setup versions based on filters.
+
+        Args:
+            setup_version_dict: Dictionary with optional 'name' or 'query_versions' filters.
+
+        Raises:
+            SetupServiceError: setup_id does not exist.
+
+        Returns:
+            List[SetupVersionData]: A list of matching setup version details.
+        """
+        if setup_version_dict["setup_id"] not in self.setup_versions:
+            msg = f"GET setup_id = {setup_version_dict['setup_id']}: setup_id DOESN'T EXIST"
+            logger.error(msg)
+            raise SetupServiceError(msg)
+
+        return [
+            value
+            for value in self.setup_versions[setup_version_dict["setup_id"]].values()
+            if setup_version_dict["query_versions"] in value.version
+        ]
+
+    def update_setup_version(self, setup_version_dict: dict[str, Any]) -> bool:
+        """Update an existing setup version.
+
+        Args:
+            setup_version_dict: Dictionary with setup version update details.
+
+        Returns:
+            bool: Success status of the update operation.
+        """
+        if setup_version_dict["setup_id"] not in self.setup_versions:
+            logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
+            return False
+
+        if setup_version_dict["version"] not in self.setup_versions[setup_version_dict["setup_id"]]:
+            logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
+            return False
+
+        try:
+            valid_data = SetupVersionData.model_validate(setup_version_dict["data"])
+        except ValidationError:
+            logger.exception("Validation failed for model SetupVersionData")
+            return False
+
+        self.setup_versions[setup_version_dict["setup_id"]][setup_version_dict["version"]] = valid_data
+        return True
+
+    def delete_setup_version(self, setup_version_dict: dict[str, Any]) -> bool:
+        """Delete a setup version by its unique identifier.
+
+        Args:
+            setup_version_dict: Dictionary with the setup version 'name'.
+
+        Returns:
+            bool: Success status of version deletion.
+        """
+        if setup_version_dict["setup_id"] not in self.setup_versions:
+            logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
+            return False
+
+        del self.setup_versions[setup_version_dict["setup_id"]][setup_version_dict["version"]]
+        return True

digitalkin/services/setup/grpc_setup.py

@@ -0,0 +1,343 @@
+"""Digital Kin Setup Service gRPC Client."""
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+import grpc
+from agentic_mesh_protocol.setup.v1 import (
+    setup_pb2,
+    setup_service_pb2_grpc,
+)
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import Struct
+from pydantic import ValidationError
+
+from digitalkin.grpc_servers.utils.exceptions import ServerError
+from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
+from digitalkin.logger import logger
+from digitalkin.models.grpc_servers.models import ClientConfig
+from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
+
+
+class GrpcSetup(SetupStrategy, GrpcClientWrapper):
+    """This class implements the gRPC setup service."""
+
+    def __post_init__(self, config: ClientConfig) -> None:
+        """Init the channel from a config file.
+
+        Need to be call if the user register a gRPC channel.
+        """
+        channel = self._init_channel(config)
+        self.stub = setup_service_pb2_grpc.SetupServiceStub(channel)
+        logger.debug("Channel client 'setup' initialized successfully")
+
+    @contextmanager
+    def handle_grpc_errors(self, operation: str) -> Generator[Any, Any, Any]:  # noqa: PLR6301
+        """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.
+            SetupServiceError: setup service internal.
+        """
+        try:
+            yield
+        except ValidationError as e:
+            msg = f"Invalid data for {operation}"
+            logger.exception(msg)
+            raise ValueError(msg) from e
+        except grpc.RpcError 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 SetupServiceError(msg) from e
+
+    def create_setup(self, setup_dict: dict[str, Any]) -> str:
+        """Create a new setup with comprehensive validation.
+
+        Args:
+            setup_dict: Dictionary containing setup details.
+
+        Returns:
+            bool: Success status of setup creation.
+
+        Raises:
+            ValidationError: If setup data is invalid.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Setup Creation"):
+            valid_data = SetupData.model_validate(setup_dict)
+
+            request = setup_pb2.CreateSetupRequest(
+                name=valid_data.name,
+                organisation_id=valid_data.organisation_id,
+                owner_id=valid_data.owner_id,
+                module_id=valid_data.module_id,
+                current_setup_version=setup_pb2.SetupVersion(**valid_data.current_setup_version.model_dump()),
+            )
+            response = self.exec_grpc_query("CreateSetup", request)
+            logger.debug("Setup '%s' query sent successfully", valid_data.name)
+            return response
+
+    def get_setup(self, setup_dict: dict[str, Any]) -> SetupData:
+        """Retrieve a setup by its unique identifier.
+
+        Args:
+            setup_dict: Dictionary with 'name' and optional 'version'.
+
+        Returns:
+            dict[str, Any]: Setup details including optional setup version.
+
+        Raises:
+            ValidationError: If the setup name is missing.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Get Setup"):
+            if "setup_id" not in setup_dict:
+                msg = "Setup name is required"
+                raise ValidationError(msg)
+            request = setup_pb2.GetSetupRequest(
+                setup_id=setup_dict["setup_id"],
+                version=setup_dict.get("version", ""),
+            )
+            response = self.exec_grpc_query("GetSetup", request)
+            response_data = json_format.MessageToDict(response, preserving_proto_field_name=True)
+            return SetupData(**response_data["setup"])
+
+    def update_setup(self, setup_dict: dict[str, Any]) -> bool:
+        """Update an existing setup.
+
+        Args:
+            setup_dict: Dictionary with setup update details.
+
+        Returns:
+            bool: Success status of the update operation.
+
+        Raises:
+            ValidationError: If setup data is invalid.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        current_setup_version = None
+
+        with self.handle_grpc_errors("Setup Update"):
+            valid_data = SetupData.model_validate(setup_dict)
+
+            if valid_data.current_setup_version is not None:
+                current_setup_version = setup_pb2.SetupVersion(**valid_data.current_setup_version.model_dump())
+
+            request = setup_pb2.UpdateSetupRequest(
+                setup_id=valid_data.id,
+                name=valid_data.name,
+                owner_id=valid_data.owner_id or "",
+                current_setup_version=current_setup_version,
+            )
+            response = self.exec_grpc_query("UpdateSetup", request)
+            logger.debug("Setup '%s' query sent successfully", valid_data.name)
+            return getattr(response, "success", False)
+
+    def delete_setup(self, setup_dict: dict[str, Any]) -> bool:
+        """Delete a setup by its unique identifier.
+
+        Args:
+            setup_dict: Dictionary with the setup 'setup_id'.
+
+        Returns:
+            bool: Success status of deletion.
+
+        Raises:
+            ValidationError: If the setup setup_id is missing.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Setup Deletion"):
+            setup_id = setup_dict.get("setup_id")
+            if not setup_id:
+                msg = "Setup name is required for deletion"
+                raise ValidationError(msg)
+            request = setup_pb2.DeleteSetupRequest(setup_id=setup_id)
+            response = self.exec_grpc_query("DeleteSetup", request)
+            logger.debug("Setup '%s' query sent successfully", setup_id)
+            return getattr(response, "success", False)
+
+    def create_setup_version(self, setup_version_dict: dict[str, Any]) -> str:
+        """Create a new setup version.
+
+        Args:
+            setup_version_dict: Dictionary with setup version details.
+
+        Returns:
+            str: version of setup version creation.
+
+        Raises:
+            ValidationError: If setup version data is invalid.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Setup Version Creation"):
+            valid_data = SetupVersionData.model_validate(setup_version_dict)
+            content_struct = Struct()
+            content_struct.update(valid_data.content)
+            request = setup_pb2.CreateSetupVersionRequest(
+                setup_id=valid_data.setup_id,
+                version=valid_data.version,
+                content=content_struct,
+            )
+            logger.debug(
+                "Setup Version '%s' for setup '%s' query sent successfully",
+                valid_data.version,
+                valid_data.setup_id,
+            )
+            return self.exec_grpc_query("CreateSetupVersion", request)
+
+    def get_setup_version(self, setup_version_dict: dict[str, Any]) -> SetupVersionData:
+        """Retrieve a setup version by its unique identifier.
+
+        Args:
+            setup_version_dict: Dictionary with the setup version 'setup_version_id'.
+
+        Returns:
+            dict[str, Any]: Setup version details.
+
+        Raises:
+            ValidationError: If the setup version id is missing.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Get Setup Version"):
+            setup_version_id = setup_version_dict.get("setup_version_id")
+            if not setup_version_id:
+                msg = "Setup version id is required"
+                raise ValidationError(msg)
+            request = setup_pb2.GetSetupVersionRequest(setup_version_id=setup_version_id)
+            response = self.exec_grpc_query("GetSetupVersion", request)
+            return SetupVersionData(
+                **json_format.MessageToDict(response.setup_version, preserving_proto_field_name=True)
+            )
+
+    def search_setup_versions(self, setup_version_dict: dict[str, Any]) -> list[SetupVersionData]:
+        """Search for setup versions based on filters.
+
+        Args:
+            setup_version_dict: Dictionary with optional 'name' and 'version' filters.
+
+        Returns:
+            list[dict[str, Any]]: A list of matching setup version details.
+
+        Raises:
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+            ValidationError: If both name and version are not provided.
+        """
+        with self.handle_grpc_errors("Search Setup Versions"):
+            if "name" not in setup_version_dict and "version" not in setup_version_dict:
+                msg = "Either name or version must be provided"
+                raise ValidationError(msg)
+            request = setup_pb2.SearchSetupVersionsRequest(
+                setup_id=setup_version_dict.get("setup_id", ""),
+                version=setup_version_dict.get("version", ""),
+            )
+            response = self.exec_grpc_query("SearchSetupVersions", request)
+            return [
+                SetupVersionData(**json_format.MessageToDict(sv, preserving_proto_field_name=True))
+                for sv in response.setup_versions
+            ]
+
+    def update_setup_version(self, setup_version_dict: dict[str, Any]) -> bool:
+        """Update an existing setup version.
+
+        Args:
+            setup_version_dict: Dictionary with setup version update details.
+
+        Returns:
+            bool: Success status of the update operation.
+
+        Raises:
+            ValidationError: If setup version data is invalid.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Setup Version Update"):
+            valid_data = SetupVersionData.model_validate(setup_version_dict)
+            content_struct = Struct()
+            content_struct.update(valid_data.content)
+            request = setup_pb2.UpdateSetupVersionRequest(
+                setup_version_id=valid_data.id,
+                version=valid_data.version,
+                content=content_struct,
+            )
+            response = self.exec_grpc_query("UpdateSetupVersion", request)
+            logger.debug(
+                "Setup Version '%s' for setup '%s' query sent successfully",
+                valid_data.id,
+                valid_data.setup_id,
+            )
+            return getattr(response, "success", False)
+
+    def delete_setup_version(self, setup_version_dict: dict[str, Any]) -> bool:
+        """Delete a setup version by its unique identifier.
+
+        Args:
+            setup_version_dict: Dictionary with the setup version 'name'.
+
+        Returns:
+            bool: Success status of version deletion.
+
+        Raises:
+            ValidationError: If the setup version name is missing.
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("Setup Version Deletion"):
+            setup_version_id = setup_version_dict.get("setup_version_id")
+            if not setup_version_id:
+                msg = "Setup version id is required for deletion"
+                raise ValidationError(msg)
+            request = setup_pb2.DeleteSetupVersionRequest(setup_version_id=setup_version_id)
+            response = self.exec_grpc_query("DeleteSetupVersion", request)
+            logger.debug("Setup Version '%s' query sent successfully", setup_version_id)
+            return getattr(response, "success", False)
+
+    def list_setups(self, list_dict: dict[str, Any]) -> dict[str, Any]:
+        """List setups with optional filtering and pagination.
+
+        Args:
+            list_dict: Dictionary with optional filters:
+                - organisation_id: Filter by organisation
+                - owner_id: Filter by owner
+                - limit: Maximum number of results
+                - offset: Number of results to skip
+
+        Returns:
+            dict[str, Any]: Dictionary with 'setups' list and 'total_count'.
+
+        Raises:
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("List Setups"):
+            request = setup_pb2.ListSetupsRequest(
+                organisation_id=list_dict.get("organisation_id", ""),
+                owner_id=list_dict.get("owner_id", ""),
+                limit=list_dict.get("limit", 0),
+                offset=list_dict.get("offset", 0),
+            )
+            response = self.exec_grpc_query("ListSetups", request)
+            return {
+                "setups": [
+                    json_format.MessageToDict(setup, preserving_proto_field_name=True) for setup in response.setups
+                ],
+                "total_count": response.total_count,
+            }