digitalkin 0.3.2.dev2__py3-none-any.whl

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

@@ -0,0 +1,6 @@
+"""This module is responsible for handling the snapshot service."""
+
+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

@@ -0,0 +1,39 @@
+"""Default snapshot."""
+
+from typing import Any
+
+from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
+
+
+class DefaultSnapshot(SnapshotStrategy):
+    """Default snapshot strategy."""
+
+    def create(self, data: dict[str, Any]) -> str:  # noqa: ARG002, PLR6301
+        """Create a new snapshot in the file system.
+
+        Returns:
+            str: The ID of the new snapshot
+        """
+        return "1"
+
+    def get(self, data: dict[str, Any]) -> None:
+        """Get snapshots from the file system."""
+
+    def update(self, data: dict[str, Any]) -> int:  # noqa: ARG002, PLR6301
+        """Update snapshots in the file system.
+
+        Returns:
+            int: The number of snapshots updated
+        """
+        return 1
+
+    def delete(self, data: dict[str, Any]) -> int:  # noqa: ARG002, PLR6301
+        """Delete snapshots from the file system.
+
+        Returns:
+            int: The number of snapshots deleted
+        """
+        return 1
+
+    def get_all(self) -> None:
+        """Get all snapshots from the file system."""

digitalkin/services/snapshot/snapshot_strategy.py

@@ -0,0 +1,30 @@
+"""This module contains the abstract base class for snapshot strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from digitalkin.services.base_strategy import BaseStrategy
+
+
+class SnapshotStrategy(BaseStrategy, ABC):
+    """Abstract base class for snapshot strategies."""
+
+    @abstractmethod
+    def create(self, data: dict[str, Any]) -> str:
+        """Create a new snapshot in the file system."""
+
+    @abstractmethod
+    def get(self, data: dict[str, Any]) -> None:
+        """Get snapshots from the file system."""
+
+    @abstractmethod
+    def update(self, data: dict[str, Any]) -> int:
+        """Update snapshots in the file system."""
+
+    @abstractmethod
+    def delete(self, data: dict[str, Any]) -> int:
+        """Delete snapshots from the file system."""
+
+    @abstractmethod
+    def get_all(self) -> None:
+        """Get all snapshots from the file system."""

digitalkin/services/storage/__init__.py

@@ -0,0 +1,7 @@
+"""This module is responsible for handling the storage service."""
+
+from digitalkin.services.storage.default_storage import DefaultStorage
+from digitalkin.services.storage.grpc_storage import GrpcStorage
+from digitalkin.services.storage.storage_strategy import StorageStrategy
+
+__all__ = ["DefaultStorage", "GrpcStorage", "StorageStrategy"]

digitalkin/services/storage/default_storage.py

@@ -0,0 +1,228 @@
+"""This module implements the default storage strategy."""
+
+import datetime
+import json
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from digitalkin.logger import logger
+from digitalkin.services.storage.storage_strategy import (
+    DataType,
+    StorageRecord,
+    StorageStrategy,
+)
+
+
+class DefaultStorage(StorageStrategy):
+    """Persist records in a local JSON file for quick local development.
+
+    File format: a JSON object of
+      { "<collection>:<record_id>": { ... StorageRecord fields ... },
+    """
+
+    @staticmethod
+    def _json_default(o: Any) -> str:  # noqa: ANN401
+        """JSON serializer for non-standard types (datetime → ISO).
+
+        Args:
+            o: The object to serialize
+
+        Returns:
+            str: The serialized object
+
+        Raises:
+            TypeError: If the object is not serializable
+        """
+        if isinstance(o, datetime.datetime):
+            return o.isoformat()
+        msg = f"Type {o.__class__.__name__} not serializable"
+        raise TypeError(msg)
+
+    def _load_from_file(self) -> dict[str, StorageRecord]:
+        """Load storage data from the file.
+
+        Returns:
+            A dictionary containing the loaded storage records
+        """
+        if not self.storage_file.exists():
+            return {}
+
+        try:
+            raw = json.loads(self.storage_file.read_text(encoding="utf-8"))
+            out: dict[str, StorageRecord] = {}
+
+            for key, rd in raw.items():
+                # rd is a dict with the StorageRecord fields
+                model_cls = self.config.get(rd["collection"])
+                if not model_cls:
+                    logger.warning("No model for collection '%s'", rd["collection"])
+                    continue
+                data_model = model_cls.model_validate(rd["data"])
+                rec = StorageRecord(
+                    mission_id=rd["mission_id"],
+                    collection=rd["collection"],
+                    record_id=rd["record_id"],
+                    data=data_model,
+                    data_type=DataType[rd["data_type"]],
+                    creation_date=datetime.datetime.fromisoformat(rd["creation_date"])
+                    if rd.get("creation_date")
+                    else None,
+                    update_date=datetime.datetime.fromisoformat(rd["update_date"]) if rd.get("update_date") else None,
+                )
+                out[key] = rec
+        except Exception:
+            logger.exception("Failed to load default storage file")
+            return {}
+        return out
+
+    def _save_to_file(self) -> None:
+        """Atomically write `self.storage` back to disk as JSON."""
+        self.storage_file.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            delete=False,
+            dir=str(self.storage_file.parent),
+            suffix=".tmp",
+        ) as temp:
+            try:
+                # Convert storage to a serializable format
+                serial: dict[str, dict] = {}
+                for key, record in self.storage.items():
+                    serial[key] = {
+                        "mission_id": record.mission_id,
+                        "collection": record.collection,
+                        "record_id": record.record_id,
+                        "data_type": record.data_type.name,
+                        "data": record.data.model_dump(),
+                        "creation_date": record.creation_date.isoformat() if record.creation_date else None,
+                        "update_date": record.update_date.isoformat() if record.update_date else None,
+                    }
+                json.dump(serial, temp, indent=2, default=self._json_default)
+                temp.flush()
+                Path(temp.name).replace(self.storage_file)
+            except Exception:
+                logger.exception("Unexpected error saving storage")
+
+    def _store(self, record: StorageRecord) -> StorageRecord:
+        """Store a new record in the database and persist to file.
+
+        Args:
+            record: The record to store
+
+        Returns:
+            str: The ID of the new record
+
+        Raises:
+            ValueError: If the record already exists
+        """
+        key = f"{record.collection}:{record.record_id}"
+        if key in self.storage:
+            msg = f"Document {key!r} already exists"
+            raise ValueError(msg)
+        now = datetime.datetime.now(datetime.timezone.utc)
+        record.creation_date = now
+        record.update_date = now
+        self.storage[key] = record
+        self._save_to_file()
+        logger.debug("Created %s", key)
+        return record
+
+    def _read(self, collection: str, record_id: str) -> StorageRecord | None:
+        """Get records from the database.
+
+        Args:
+            collection: The unique name to retrieve data for
+            record_id: The unique ID of the record
+
+        Returns:
+            StorageRecord: The corresponding record
+        """
+        key = f"{collection}:{record_id}"
+        return self.storage.get(key)
+
+    def _update(self, collection: str, record_id: str, data: BaseModel) -> StorageRecord | None:
+        """Update records in the database and persist to file.
+
+        Args:
+            collection: The unique name to retrieve data for
+            record_id: The unique ID of the record
+            data: The data to modify
+
+        Returns:
+            StorageRecord: The modified record
+        """
+        key = f"{collection}:{record_id}"
+        rec = self.storage.get(key)
+        if not rec:
+            return None
+        rec.data = data
+        rec.update_date = datetime.datetime.now(datetime.timezone.utc)
+        self._save_to_file()
+        logger.debug("Modified %s", key)
+        return rec
+
+    def _remove(self, collection: str, record_id: str) -> bool:
+        """Delete records from the database and update file.
+
+        Args:
+            collection: The unique name to retrieve data for
+            record_id: The unique ID of the record
+
+        Returns:
+            bool: True if the record was removed, False otherwise
+        """
+        key = f"{collection}:{record_id}"
+        if key not in self.storage:
+            return False
+        del self.storage[key]
+        self._save_to_file()
+        logger.debug("Removed %s", key)
+        return True
+
+    def _list(self, collection: str) -> list[StorageRecord]:
+        """Implements StorageStrategy._list.
+
+        Args:
+            collection: The unique name to retrieve data for
+
+        Returns:
+            A list of storage records
+        """
+        prefix = f"{collection}:"
+        return [r for k, r in self.storage.items() if k.startswith(prefix)]
+
+    def _remove_collection(self, collection: str) -> bool:
+        """Implements StorageStrategy._remove_collection.
+
+        Args:
+            collection: The unique name to retrieve data for
+
+        Returns:
+            bool: True if the collection was removed, False otherwise
+        """
+        prefix = f"{collection}:"
+        to_delete = [k for k in self.storage if k.startswith(prefix)]
+        for k in to_delete:
+            del self.storage[k]
+        self._save_to_file()
+        logger.debug("Removed collection %s (%d docs)", collection, len(to_delete))
+        return True
+
+    def __init__(
+        self,
+        mission_id: str,
+        setup_id: str,
+        setup_version_id: str,
+        config: dict[str, type[BaseModel]],
+        storage_file_path: str = "local_storage",
+        **kwargs,  # noqa: ANN003, ARG002
+    ) -> None:
+        """Initialize the storage."""
+        super().__init__(mission_id=mission_id, setup_id=setup_id, setup_version_id=setup_version_id, config=config)
+        self.storage_file_path = f"{self.mission_id}_{storage_file_path}.json"
+        self.storage_file = Path(self.storage_file_path)
+        self.storage = self._load_from_file()

digitalkin/services/storage/grpc_storage.py

@@ -0,0 +1,214 @@
+"""This module implements the default storage strategy."""
+
+from agentic_mesh_protocol.storage.v1 import data_pb2, storage_service_pb2_grpc
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import Struct
+from pydantic import BaseModel
+
+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.storage.storage_strategy import (
+    DataType,
+    StorageRecord,
+    StorageServiceError,
+    StorageStrategy,
+)
+
+
+class GrpcStorage(StorageStrategy, GrpcClientWrapper):
+    """This class implements the default storage strategy."""
+
+    def _build_record_from_proto(self, proto: data_pb2.StorageRecord) -> StorageRecord:
+        """Convert a protobuf StorageRecord message into our Pydantic model.
+
+        Args:
+            proto: gRPC StorageRecord
+
+        Returns:
+            A fully validated StorageRecord.
+        """
+        raw = json_format.MessageToDict(
+            proto,
+            preserving_proto_field_name=True,
+            always_print_fields_with_no_presence=True,
+        )
+        mission = raw["mission_id"]
+        coll = raw["collection"]
+        rid = raw["record_id"]
+        dtype = DataType[raw["data_type"]]
+        payload = raw.get("data", {})
+
+        validated = self._validate_data(coll, payload)
+        return StorageRecord(
+            mission_id=mission,
+            collection=coll,
+            record_id=rid,
+            data=validated,
+            data_type=dtype,
+            creation_date=raw.get("creation_date"),
+            update_date=raw.get("update_date"),
+        )
+
+    def _store(self, record: StorageRecord) -> StorageRecord:
+        """Create a new record in the database.
+
+        Parameters:
+            record: The record to store
+
+        Returns:
+            StorageRecord: The corresponding record
+
+        Raises:
+            StorageServiceError: If there is an error while storing the record
+        """
+        try:
+            data_struct = Struct()
+            data_struct.update(record.data.model_dump())
+            req = data_pb2.StoreRecordRequest(
+                data=data_struct,
+                mission_id=record.mission_id,
+                collection=record.collection,
+                record_id=record.record_id,
+                data_type=record.data_type.name,
+            )
+            resp = self.exec_grpc_query("StoreRecord", req)
+            return self._build_record_from_proto(resp.stored_data)
+        except Exception as e:
+            logger.exception(
+                "gRPC StoreRecord failed for %s:%s",
+                record.collection,
+                record.record_id,
+            )
+            raise StorageServiceError(str(e)) from e
+
+    def _read(self, collection: str, record_id: str) -> StorageRecord | None:
+        """Fetch a single document by collection + record_id.
+
+        Returns:
+            StorageData: The record
+        """
+        try:
+            req = data_pb2.ReadRecordRequest(
+                mission_id=self.mission_id,
+                collection=collection,
+                record_id=record_id,
+            )
+            resp = self.exec_grpc_query("ReadRecord", req)
+            return self._build_record_from_proto(resp.stored_data)
+        except Exception:
+            logger.warning("gRPC ReadRecord failed for %s:%s", collection, record_id)
+            return None
+
+    def _update(
+        self,
+        collection: str,
+        record_id: str,
+        data: BaseModel,
+    ) -> StorageRecord | None:
+        """Overwrite a document via gRPC.
+
+        Args:
+            collection: The unique name for the record type
+            record_id: The unique ID for the record
+            data: The validated data model
+
+        Returns:
+            StorageRecord: The updated record
+        """
+        try:
+            struct = Struct()
+            struct.update(data.model_dump())
+            req = data_pb2.UpdateRecordRequest(
+                data=struct,
+                mission_id=self.mission_id,
+                collection=collection,
+                record_id=record_id,
+            )
+            resp = self.exec_grpc_query("UpdateRecord", req)
+            return self._build_record_from_proto(resp.stored_data)
+        except Exception:
+            logger.warning("gRPC UpdateRecord failed for %s:%s", collection, record_id)
+            return None
+
+    def _remove(self, collection: str, record_id: str) -> bool:
+        """Delete a document via gRPC.
+
+        Args:
+            collection: The unique name for the record type
+            record_id: The unique ID for the record
+
+        Returns:
+            bool: True if the record was deleted, False otherwise
+        """
+        try:
+            req = data_pb2.RemoveRecordRequest(
+                mission_id=self.mission_id,
+                collection=collection,
+                record_id=record_id,
+            )
+            self.exec_grpc_query("RemoveRecord", req)
+        except Exception:
+            logger.warning(
+                "gRPC RemoveRecord failed for %s:%s",
+                collection,
+                record_id,
+            )
+            return False
+        return True
+
+    def _list(self, collection: str) -> list[StorageRecord]:
+        """List all documents in a collection via gRPC.
+
+        Args:
+            collection: The unique name for the record type
+
+        Returns:
+            list[StorageRecord]: A list of storage records
+        """
+        try:
+            req = data_pb2.ListRecordsRequest(
+                mission_id=self.mission_id,
+                collection=collection,
+            )
+            resp = self.exec_grpc_query("ListRecords", req)
+            return [self._build_record_from_proto(r) for r in resp.records]
+        except Exception:
+            logger.warning("gRPC ListRecords failed for %s", collection)
+            return []
+
+    def _remove_collection(self, collection: str) -> bool:
+        """Delete an entire collection via gRPC.
+
+        Args:
+            collection: The unique name for the record type
+
+        Returns:
+            bool: True if the collection was deleted, False otherwise
+        """
+        try:
+            req = data_pb2.RemoveCollectionRequest(
+                mission_id=self.mission_id,
+                collection=collection,
+            )
+            self.exec_grpc_query("RemoveCollection", req)
+        except Exception:
+            logger.warning("gRPC RemoveCollection failed for %s", collection)
+            return False
+        return True
+
+    def __init__(
+        self,
+        mission_id: str,
+        setup_id: str,
+        setup_version_id: str,
+        config: dict[str, type[BaseModel]],
+        client_config: ClientConfig,
+        **kwargs,  # noqa: ANN003, ARG002
+    ) -> None:
+        """Initialize the storage."""
+        super().__init__(mission_id=mission_id, setup_id=setup_id, setup_version_id=setup_version_id, config=config)
+
+        channel = self._init_channel(client_config)
+        self.stub = storage_service_pb2_grpc.StorageServiceStub(channel)
+        logger.debug("Channel client 'storage' initialized successfully")