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

digitalkin/services/setup/default_setup.py

@@ -0,0 +1,222 @@
+"""This module contains the abstract base class for setup strategies."""
+
+import logging
+import secrets
+import string
+from typing import Any
+
+from pydantic import ValidationError
+
+from digitalkin.services.setup.grpc_setup import SetupData, SetupVersionData
+from digitalkin.services.setup.setup_strategy import SetupServiceError, SetupStrategy
+
+logger = logging.getLogger(__name__)
+
+
+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.info("CREATE SETUP DATA %s:%s succesfull", 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.info("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.info("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.info("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.info("CREATE SETUP VERSION DATA %s:%s succesfull", 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.info("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 setup_version_dict["setup_id"].values()
+            if setup_version_dict["query_versions"] in value.version or setup_version_dict["name"] in value.name
+        ]
+
+    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.info("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_id"]:
+            logger.info("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.info("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,307 @@
+"""Digital Kin Setup Service gRPC Client."""
+
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+import grpc
+from digitalkin_proto.digitalkin.setup.v2 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.grpc_servers.utils.models import ServerConfig
+from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcSetup(SetupStrategy, GrpcClientWrapper):
+    """This class implements the gRPC setup service."""
+
+    def __post_init__(self, config: ServerConfig) -> 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.info("Channel client 'setup' initialized succesfully")
+
+    @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.info("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(
+                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.info("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.info("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.info(
+                "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))
+
+    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)) 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.info(
+                "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.info("Setup Version '%s' query sent successfully", setup_version_id)
+            return getattr(response, "success", False)

digitalkin/services/setup/setup_strategy.py

@@ -0,0 +1,145 @@
+"""This module contains the abstract base class for setup strategies."""
+
+import datetime
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class SetupServiceError(Exception):
+    """Base exception for Setup service errors."""
+
+
+class SetupVersionData(BaseModel):
+    """Pydantic model for SetupVersion data validation."""
+
+    id: str
+    setup_id: str
+    version: str
+    content: dict[str, Any]
+    creation_date: datetime.datetime
+
+
+class SetupData(BaseModel):
+    """Pydantic model for Setup data validation."""
+
+    id: str
+    name: str
+    organisation_id: str
+    owner_id: str
+    module_id: str
+    current_setup_version: SetupVersionData
+
+
+class SetupStrategy(ABC):
+    """Abstract base class for setup strategies."""
+
+    def __init__(self) -> None:
+        """Initialize the setup strategy."""
+
+    def __post_init__(self, *args, **kwargs) -> None:  # noqa: ANN002, ANN003
+        """Initialize the setup strategy."""
+
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    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: name of setup version creation.
+        """
+
+    @abstractmethod
+    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'.
+
+        Returns:
+            Dict[str, Any]: Setup version details.
+        """
+
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    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.
+        """

digitalkin/services/snapshot/__init__.py

@@ -1,6 +1,6 @@
 """This module is responsible for handling the snapshot service."""
 
-from .default_snapshot import DefaultSnapshot
-from .snapshot_strategy import SnapshotStrategy
+from digitalkin.services.snapshot.default_snapshot import DefaultSnapshot
+from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 
 __all__ = ["DefaultSnapshot", "SnapshotStrategy"]

digitalkin/services/snapshot/default_snapshot.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-from .snapshot_strategy import SnapshotStrategy
+from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 
 
 class DefaultSnapshot(SnapshotStrategy):