digitalkin 0.2.10__tar.gz → 0.2.12__tar.gz

{digitalkin-0.2.10 → digitalkin-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.10
+Version: 0.2.12
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,7 +452,7 @@ Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto>=0.1.8
+Requires-Dist: digitalkin-proto>=0.1.10
 Requires-Dist: grpcio-health-checking>=1.71.0
 Requires-Dist: grpcio-reflection>=1.71.0
 Requires-Dist: grpcio-status>=1.71.0

{digitalkin-0.2.10 → digitalkin-0.2.12}/examples/modules/storage_module.py

@@ -62,7 +62,7 @@ class ExampleModule(ArchetypeModule[ExampleInput, ExampleOutput, ExampleSetup, E
 
     # Define services_config_params with default values
     services_config_strategies = {}
-    services_config_params = {"storage": {"config": {"example_outputs": ExampleOutput}}, "filesystem": {"config": {}}}
+    services_config_params = {"storage": {"config": {"example": ExampleOutput}}, "filesystem": {"config": {}}}
 
     def __init__(self, job_id: str, mission_id: str) -> None:
         """Initialize the example module.
@@ -172,7 +172,7 @@ async def test_module() -> None:
 def test_storage_directly() -> None:
     """Test the storage service directly."""
     # Initialize storage service
-    storage = ServicesConfig().storage(mission_id="test-mission", config={"test_table": ExampleStorage})
+    storage = ServicesConfig().storage(mission_id="test-mission", config={"example": ExampleStorage})
 
     # Create a test record
     storage.store("example", "test_table", {"test_key": "test_value"}, "OUTPUT")

{digitalkin-0.2.10 → digitalkin-0.2.12}/pyproject.toml

@@ -12,7 +12,7 @@
 
     keywords = [ "digitalkin", "kin", "agent", "gprc", "sdk" ]
     # Version of the package automatically updated by bump2version (that is why it is separated)
-    version = "0.2.10"
+    version = "0.2.12"
 
     classifiers = [
         "Development Status :: 3 - Alpha",
@@ -29,13 +29,13 @@
     ]
 
     dependencies = [
-        "digitalkin-proto>=0.1.8",
+        "digitalkin-proto>=0.1.10",
         "grpcio-health-checking>=1.71.0",
         "grpcio-reflection>=1.71.0",
         "grpcio-status>=1.71.0",
         "openai>=1.76.2",
         "pydantic>=2.11.4",
-    ]
+]
 
     [project.optional-dependencies]
         dev = [
@@ -182,6 +182,9 @@
                 "ARG002",
             ]
 
+        [tool.ruff.lint.pylint]
+            max-args = 10
+
     [tool.ruff.format]
         quote-style               = "double"
         indent-style              = "space"

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "0.2.10"
+    __version__ = "0.2.12"

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/grpc_servers/module_servicer.py

@@ -96,6 +96,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer):
             input_data,
             setup_data,
             mission_id=request.mission_id,
+            setup_version_id=setup_data_class.current_setup_version.id,
             callback=self.add_to_queue,
         )
         job_id, module = result

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/modules/_base_module.py

@@ -48,17 +48,19 @@ class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretMode
     def _init_strategies(self) -> None:
         """Initialize the services configuration."""
         for service_name in self.services_config.valid_strategy_names():
-            service = self.services_config.init_strategy(service_name, self.mission_id)
+            service = self.services_config.init_strategy(service_name, self.mission_id, self.setup_version_id)
             setattr(self, service_name, service)
 
     def __init__(
         self,
         job_id: str,
         mission_id: str,
+        setup_version_id: str,
     ) -> None:
         """Initialize the module."""
         self.job_id: str = job_id
         self.mission_id: str = mission_id
+        self.setup_version_id: str = setup_version_id
         self._status = ModuleStatus.CREATED
         self._task: asyncio.Task | None = None
         # Initialize services configuration

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/modules/job_manager.py

@@ -79,6 +79,7 @@ class JobManager(ArgParser):
         input_data: InputModelT,
         setup_data: SetupModelT,
         mission_id: str,
+        setup_version_id: str,
         callback: Callable[[str, OutputModelT], Coroutine[Any, Any, None]],
     ) -> tuple[str, BaseModule[InputModelT, OutputModelT, SetupModelT, SecretModelT]]:  # type: ignore
         """Start new module job in background (asyncio).
@@ -94,7 +95,7 @@ class JobManager(ArgParser):
         job_id = str(uuid.uuid4())
         """TODO: check uniqueness of the job_id"""
         # Création et démarrage du module
-        module = self.module_class(job_id, mission_id=mission_id)
+        module = self.module_class(job_id, mission_id=mission_id, setup_version_id=setup_version_id)
         self.modules[job_id] = module
         try:
             await module.start(input_data, setup_data, await JobManager._job_specific_callback(callback, job_id))

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/base_strategy.py

@@ -9,10 +9,12 @@ class BaseStrategy(ABC):
     This class defines the interface for all strategies.
     """
 
-    def __init__(self, mission_id: str) -> None:
+    def __init__(self, mission_id: str, setup_version_id: str) -> None:
         """Initialize the strategy.
 
         Args:
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
         """
         self.mission_id: str = mission_id
+        self.setup_version_id: str = setup_version_id

digitalkin-0.2.12/src/digitalkin/services/cost/cost_strategy.py

@@ -0,0 +1,93 @@
+"""This module contains the abstract base class for cost strategies."""
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel
+
+from digitalkin.services.base_strategy import BaseStrategy
+
+
+class CostType(Enum):
+    """Enum defining the types of costs that can be registered."""
+
+    OTHER = "OTHER"
+    TOKEN_INPUT = "TOKEN_INPUT"
+    TOKEN_OUTPUT = "TOKEN_OUTPUT"
+    API_CALL = "API_CALL"
+    STORAGE = "STORAGE"
+    TIME = "TIME"
+
+
+class CostConfig(BaseModel):
+    """Pydantic model that defines a cost configuration.
+
+    :param cost_name: Name of the cost (unique identifier in the service).
+    :param cost_type: The type/category of the cost.
+    :param description: A short description of the cost.
+    :param unit: The unit of measurement (e.g. token, call, MB).
+    :param rate: The cost per unit (e.g. dollars per token).
+    """
+
+    cost_name: str
+    cost_type: Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]
+    description: str | None = None
+    unit: str
+    rate: float
+
+
+class CostData(BaseModel):
+    """Data model for cost operations."""
+
+    cost: float
+    mission_id: str
+    name: str
+    cost_type: CostType
+    unit: str
+    rate: float
+    setup_version_id: str
+    quantity: float
+
+
+class CostServiceError(Exception):
+    """Custom exception for CostService errors."""
+
+
+class CostStrategy(BaseStrategy, ABC):
+    """Abstract base class for cost strategies."""
+
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, CostConfig]) -> None:
+        """Initialize the strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
+            config: Configuration dictionary for the strategy
+        """
+        super().__init__(mission_id, setup_version_id)
+        self.config = config
+
+    @abstractmethod
+    def add(
+        self,
+        name: str,
+        cost_config_name: str,
+        quantity: float,
+    ) -> None:
+        """Register a new cost."""
+
+    @abstractmethod
+    def get(
+        self,
+        name: str,
+    ) -> list[CostData]:
+        """Get a cost."""
+
+    @abstractmethod
+    def get_filtered(
+        self,
+        names: list[str] | None = None,
+        cost_types: list[Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]] | None = None,
+    ) -> list[CostData]:
+        """Get filtered costs."""

digitalkin-0.2.12/src/digitalkin/services/cost/default_cost.py

@@ -0,0 +1,109 @@
+"""Default cost."""
+
+import logging
+from typing import Literal
+
+from digitalkin.services.cost.cost_strategy import CostConfig, CostData, CostServiceError, CostStrategy, CostType
+
+logger = logging.getLogger(__name__)
+
+
+class DefaultCost(CostStrategy):
+    """Default cost strategy."""
+
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, CostConfig]) -> None:
+        """Initialize the strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
+            config: The configuration dictionary for the cost
+        """
+        super().__init__(mission_id=mission_id, setup_version_id=setup_version_id, config=config)
+        self.db: dict[str, list[CostData]] = {}
+
+    def add(
+        self,
+        name: str,
+        cost_config_name: str,
+        quantity: float,
+    ) -> None:
+        """Create a new record in the cost database.
+
+        Args:
+            name: The name of the cost
+            cost_config_name: The name of the cost config
+            quantity: The quantity of the cost
+
+        Raises:
+            CostServiceError: If the cost data is invalid or if the cost already exists
+        """
+        cost_config = self.config.get(cost_config_name)
+        if cost_config is None:
+            msg = f"Cost config {cost_config_name} not found in the configuration."
+            logger.error(msg)
+            raise CostServiceError(msg)
+        cost_data = CostData.model_validate({
+            "name": name,
+            "cost": cost_config.rate * quantity,
+            "unit": cost_config.unit,
+            "cost_type": getattr(CostType, cost_config.cost_type),
+            "mission_id": self.mission_id,
+            "rate": cost_config.rate,
+            "quantity": quantity,
+            "setup_version_id": self.setup_version_id,
+        })
+        if cost_data.mission_id not in self.db:
+            self.db[cost_data.mission_id] = []
+        if cost_data.name in [cost.name for cost in self.db[cost_data.mission_id]]:
+            msg = f"Cost with name {cost_data.name} already exists in mission {cost_data.mission_id}"
+            logger.error(msg)
+            raise CostServiceError(msg)
+        self.db[cost_data.mission_id].append(cost_data)
+
+    def get(self, name: str) -> list[CostData]:
+        """Get a record from the database.
+
+        Args:
+            name: The name of the cost
+
+        Returns:
+            list[CostData]: The cost data
+
+        Raises:
+            CostServiceError: If the cost data is invalid or if the cost does not exist
+        """
+        if self.mission_id not in self.db:
+            msg = f"Mission {self.mission_id} not found in the database."
+            logger.warning(msg)
+            raise CostServiceError(msg)
+
+        return [cost for cost in self.db[self.mission_id] if cost.name == name] or []
+
+    def get_filtered(
+        self,
+        names: list[str] | None = None,
+        cost_types: list[Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]] | None = None,
+    ) -> list[CostData]:
+        """Get records from the database.
+
+        Args:
+            names: The names of the costs
+            cost_types: The types of the costs
+
+        Returns:
+            list[CostData]: The list of records
+
+        Raises:
+            CostServiceError: If the cost data is invalid or if the cost does not exist
+        """
+        if self.mission_id not in self.db:
+            msg = f"Mission {self.mission_id} not found in the database."
+            logger.warning(msg)
+            raise CostServiceError(msg)
+
+        return [
+            cost
+            for cost in self.db[self.mission_id]
+            if (names and cost.name in names) or (cost_types and cost.cost_type in cost_types)
+        ]

digitalkin-0.2.12/src/digitalkin/services/cost/grpc_cost.py

@@ -0,0 +1,162 @@
+"""This module implements the default Cost strategy."""
+
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any, Literal
+
+from digitalkin_proto.digitalkin.cost.v1 import cost_pb2, cost_service_pb2_grpc
+from google.protobuf import json_format
+
+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 ClientConfig
+from digitalkin.services.cost.cost_strategy import CostConfig, CostData, CostServiceError, CostStrategy, CostType
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcCost(CostStrategy, GrpcClientWrapper):
+    """This class implements the default Cost strategy."""
+
+    @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 with the model validation.
+            ServerError: from gRPC Client.
+            CostServiceError: Unexpected error.
+        """
+        try:
+            yield
+        except CostServiceError as e:
+            msg = f"CostServiceError in {operation}: {e}"
+            logger.exception(msg)
+            raise CostServiceError(msg) from e
+        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 CostServiceError(msg) from e
+
+    def __init__(
+        self, mission_id: str, setup_version_id: str, config: dict[str, CostConfig], client_config: ClientConfig
+    ) -> None:
+        """Initialize the cost."""
+        super().__init__(mission_id=mission_id, setup_version_id=setup_version_id, config=config)
+        channel = self._init_channel(client_config)
+        self.stub = cost_service_pb2_grpc.CostServiceStub(channel)
+        logger.info("Channel client 'Cost' initialized succesfully")
+
+    def add(
+        self,
+        name: str,
+        cost_config_name: str,
+        quantity: float,
+    ) -> None:
+        """Create a new record in the cost database.
+
+        Args:
+            name: The name of the cost
+            cost_config_name: The name of the cost config
+            quantity: The quantity of the cost
+
+        Raises:
+            CostServiceError: If the cost config is invalid
+        """
+        with self._handle_grpc_errors("AddCost"):
+            cost_config = self.config.get(cost_config_name)
+            if cost_config is None:
+                msg = f"Cost config {cost_config_name} not found in the configuration."
+                logger.error(msg)
+                raise CostServiceError(msg)
+            valid_data = CostData.model_validate({
+                "name": name,
+                "cost": cost_config.rate * quantity,
+                "unit": cost_config.unit,
+                "cost_type": CostType[cost_config.cost_type],
+                "mission_id": self.mission_id,
+                "rate": cost_config.rate,
+                "quantity": quantity,
+                "setup_version_id": self.setup_version_id,
+            })
+            request = cost_pb2.AddCostRequest(
+                cost=valid_data.cost,
+                name=valid_data.name,
+                unit=valid_data.unit,
+                cost_type=valid_data.cost_type.name,
+                mission_id=valid_data.mission_id,
+                rate=valid_data.rate,
+                quantity=valid_data.quantity,
+                setup_version_id=valid_data.setup_version_id,
+            )
+            self.exec_grpc_query("AddCost", request)
+            logger.debug("Cost added with cost_dict: %s", valid_data.model_dump())
+
+    def get(self, name: str) -> list[CostData]:
+        """Get a record from the database.
+
+        Args:
+            name: The name of the cost
+
+        Returns:
+            CostData: The cost data
+        """
+        with self._handle_grpc_errors("GetCost"):
+            request = cost_pb2.GetCostRequest(name=name, mission_id=self.mission_id)
+            response: cost_pb2.GetCostResponse = self.exec_grpc_query("GetCost", request)
+            cost_data_list = [
+                json_format.MessageToDict(
+                    cost,
+                    preserving_proto_field_name=True,
+                    always_print_fields_with_no_presence=True,
+                )
+                for cost in response.costs
+            ]
+            logger.debug("Costs retrieved with cost_dict: %s", cost_data_list)
+            return [CostData.model_validate(cost_data) for cost_data in cost_data_list]
+
+    def get_filtered(
+        self,
+        names: list[str] | None = None,
+        cost_types: list[Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]] | None = None,
+    ) -> list[CostData]:
+        """Get a list of records from the database.
+
+        Args:
+            names: The names of the costs
+            cost_types: The types of the costs
+
+        Returns:
+            list[CostData]: The cost data
+        """
+        with self._handle_grpc_errors("GetCosts"):
+            request = cost_pb2.GetCostsRequest(
+                mission_id=self.mission_id,
+                filter=cost_pb2.CostFilter(
+                    names=names or [],
+                    cost_types=cost_types or [],
+                ),
+            )
+            response: cost_pb2.GetCostsResponse = self.exec_grpc_query("GetCosts", request)
+            cost_data_list = [
+                json_format.MessageToDict(
+                    cost,
+                    preserving_proto_field_name=True,
+                    always_print_fields_with_no_presence=True,
+                )
+                for cost in response.costs
+            ]
+            logger.debug("Filtered costs retrieved with cost_dict: %s", cost_data_list)
+            return [CostData.model_validate(cost_data) for cost_data in cost_data_list]

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/filesystem/default_filesystem.py

@@ -18,14 +18,15 @@ logger = logging.getLogger(__name__)
 class DefaultFilesystem(FilesystemStrategy):
     """Default state filesystem strategy."""
 
-    def __init__(self, mission_id: str, config: dict[str, str]) -> None:
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, str]) -> None:
         """Initialize the default filesystem strategy.
 
         Args:
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
             config: A dictionary mapping names to Pydantic model classes
         """
-        super().__init__(mission_id, config)
+        super().__init__(mission_id, setup_version_id, config)
         self.temp_root: str = self.config.get("temp_root", "") or tempfile.gettempdir()
         os.makedirs(self.temp_root, exist_ok=True)
         self.db: dict[str, FilesystemData] = {}

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/filesystem/filesystem_strategy.py

@@ -35,14 +35,15 @@ class FilesystemData(BaseModel):
 class FilesystemStrategy(BaseStrategy, ABC):
     """Abstract base class for filesystem strategies."""
 
-    def __init__(self, mission_id: str, config: dict[str, str]) -> None:
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, str]) -> None:
         """Initialize the strategy.
 
         Args:
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
             config: configuration dictionary for the filesystem strategy
         """
-        super().__init__(mission_id)
+        super().__init__(mission_id, setup_version_id)
         self.config: dict[str, str] = config
 
     @abstractmethod

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/filesystem/grpc_filesystem.py

@@ -24,26 +24,6 @@ logger = logging.getLogger(__name__)
 class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
     """Default state filesystem strategy."""
 
-    def __init__(
-        self,
-        mission_id: str,
-        config: dict[str, str],
-        client_config: ClientConfig,
-        **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
-            client_config: The client configuration object
-            kwargs: other optional arguments to pass to the parent class constructor
-        """
-        super().__init__(mission_id, config)
-        channel = self._init_channel(client_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]:
@@ -56,7 +36,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             operation: Description of the operation being performed.
 
         Raises:
-            ValueError: Error wiht the model validation.
+            ValueError: Error with the model validation.
             ServerError: from gRPC Client.
             FilesystemServiceError: Filesystem service internal.
         """
@@ -71,6 +51,28 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             logger.exception(msg)
             raise FilesystemServiceError(msg) from e
 
+    def __init__(
+        self,
+        mission_id: str,
+        setup_version_id: str,
+        config: dict[str, str],
+        client_config: ClientConfig,
+        **kwargs,  # noqa: ANN003, ARG002
+    ) -> None:
+        """Initialize the default filesystem strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
+            config: A dictionary mapping names to Pydantic model classes
+            client_config: The server configuration object
+            kwargs: other optional arguments to pass to the parent class constructor
+        """
+        super().__init__(mission_id, setup_version_id, config)
+        channel = self._init_channel(client_config)
+        self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
+        logger.info("Channel client 'Filesystem' initialized succesfully")
+
     def upload(self, content: bytes, name: str, file_type: FileType) -> FilesystemData:
         """Create a new file in the file system.
 

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/services_config.py

@@ -5,7 +5,7 @@ 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.cost import CostStrategy, DefaultCost, GrpcCost
 from digitalkin.services.filesystem import DefaultFilesystem, FilesystemStrategy, GrpcFilesystem
 from digitalkin.services.identity import DefaultIdentity, IdentityStrategy
 from digitalkin.services.registry import DefaultRegistry, RegistryStrategy
@@ -30,7 +30,7 @@ class ServicesConfig(BaseModel):
     )
     _config_storage: dict[str, Any | None] = PrivateAttr(default_factory=dict)
     _cost: ServicesStrategy[CostStrategy] = PrivateAttr(
-        default_factory=lambda: ServicesStrategy(local=DefaultCost, remote=DefaultCost)
+        default_factory=lambda: ServicesStrategy(local=DefaultCost, remote=GrpcCost)
     )
     _config_cost: dict[str, Any | None] = PrivateAttr(default_factory=dict)
     _snapshot: ServicesStrategy[SnapshotStrategy] = PrivateAttr(
@@ -111,12 +111,13 @@ class ServicesConfig(BaseModel):
         """
         return getattr(self, f"_config_{name}", {})
 
-    def init_strategy(self, name: str, mission_id: str) -> ServicesStrategy:
+    def init_strategy(self, name: str, mission_id: str, setup_version_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
+            setup_version_id: The setup version ID for the strategy
 
         Returns:
             The initialized strategy instance
@@ -129,8 +130,8 @@ class ServicesConfig(BaseModel):
             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 {})
+        # Instantiate the strategy with the mission ID, setup version ID, and configuration
+        return strategy_type(mission_id, setup_version_id, **self.get_strategy_config(name) or {})
 
     @property
     def storage(self) -> type[StorageStrategy]:

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/storage/default_storage.py

@@ -209,12 +209,13 @@ class DefaultStorage(StorageStrategy):
     def __init__(
         self,
         mission_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, config=config)
+        super().__init__(mission_id=mission_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-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/storage/grpc_storage.py

@@ -37,7 +37,7 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
         dtype = DataType[raw["data_type"]]
         payload = raw.get("data", {})
 
-        validated = self._validate_data(rid, payload)
+        validated = self._validate_data(coll, payload)
         return StorageRecord(
             mission_id=mission,
             collection=coll,
@@ -185,12 +185,13 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
     def __init__(
         self,
         mission_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, config=config)
+        super().__init__(mission_id=mission_id, setup_version_id=setup_version_id, config=config)
 
         channel = self._init_channel(client_config)
         self.stub = storage_service_pb2_grpc.StorageServiceStub(channel)

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin/services/storage/storage_strategy.py

@@ -39,11 +39,11 @@ class StorageRecord(BaseModel):
 class StorageStrategy(BaseStrategy, ABC):
     """Define CRUD + list/remove-collection against a collection/record store."""
 
-    def _validate_data(self, record_id: str, data: dict[str, Any]) -> BaseModel:
+    def _validate_data(self, collection: str, data: dict[str, Any]) -> BaseModel:
         """Validate data against the model schema for the given key.
 
         Args:
-            record_id: The unique ID for the record
+            collection: The unique name for the record type
             data: The data to validate
 
         Returns:
@@ -52,15 +52,15 @@ class StorageStrategy(BaseStrategy, ABC):
         Raises:
             ValueError: If the key has no associated model or validation fails
         """
-        model_cls = self.config.get(record_id)
+        model_cls = self.config.get(collection)
         if not model_cls:
-            msg = f"No schema registered for collection '{record_id}'"
+            msg = f"No schema registered for collection '{collection}'"
             raise ValueError(msg)
 
         try:
             return model_cls.model_validate(data)
         except Exception as e:
-            msg = f"Validation failed for '{record_id}': {e!s}"
+            msg = f"Validation failed for '{collection}': {e!s}"
             raise ValueError(msg) from e
 
     def _create_storage_record(
@@ -163,14 +163,15 @@ class StorageStrategy(BaseStrategy, ABC):
             True if the deletion was successful, False otherwise
         """
 
-    def __init__(self, mission_id: str, config: dict[str, type[BaseModel]]) -> None:
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, type[BaseModel]]) -> None:
         """Initialize the storage strategy.
 
         Args:
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version
             config: A dictionary mapping names to Pydantic model classes
         """
-        super().__init__(mission_id)
+        super().__init__(mission_id, setup_version_id)
         # Schema configuration mapping keys to model classes
         self.config: dict[str, type[BaseModel]] = config
 
@@ -200,7 +201,7 @@ class StorageStrategy(BaseStrategy, ABC):
             raise ValueError(msg)
         record_id = record_id or uuid4().hex
         data_type_enum = DataType[data_type]
-        validated_data = self._validate_data(record_id, {**data, "mission_id": self.mission_id})
+        validated_data = self._validate_data(collection, {**data, "mission_id": self.mission_id})
         record = self._create_storage_record(collection, record_id, validated_data, data_type_enum)
         return self._store(record)
 
@@ -227,7 +228,7 @@ class StorageStrategy(BaseStrategy, ABC):
         Returns:
             StorageRecord: The modified record
         """
-        validated_data = self._validate_data(record_id, data)
+        validated_data = self._validate_data(collection, data)
         return self._update(collection, record_id, validated_data)
 
     def remove(self, collection: str, record_id: str) -> bool:

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.10
+Version: 0.2.12
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,7 +452,7 @@ Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto>=0.1.8
+Requires-Dist: digitalkin-proto>=0.1.10
 Requires-Dist: grpcio-health-checking>=1.71.0
 Requires-Dist: grpcio-reflection>=1.71.0
 Requires-Dist: grpcio-status>=1.71.0

{digitalkin-0.2.10 → digitalkin-0.2.12}/src/digitalkin.egg-info/requires.txt

@@ -1,4 +1,4 @@
-digitalkin-proto>=0.1.8
+digitalkin-proto>=0.1.10
 grpcio-health-checking>=1.71.0
 grpcio-reflection>=1.71.0
 grpcio-status>=1.71.0

digitalkin-0.2.10/src/digitalkin/services/cost/cost_strategy.py

@@ -1,45 +0,0 @@
-"""This module contains the abstract base class for cost strategies."""
-
-from abc import ABC, abstractmethod
-from enum import Enum, auto
-from typing import Any
-
-from pydantic import BaseModel
-
-from digitalkin.services.base_strategy import BaseStrategy
-
-
-class CostType(Enum):
-    """."""
-
-    OTHER = auto()
-    TOKEN_INPUT = auto()
-    TOKEN_OUTPUT = auto()
-    API_CALL = auto()
-    STORAGE = auto()
-    TIME = auto()
-
-
-class CostData(BaseModel):
-    """."""
-
-    cost: float
-    mission_id: str
-    name: str
-    type: CostType
-    unit: str
-
-
-class CostStrategy(BaseStrategy, ABC):
-    """Abstract base class for cost strategies."""
-
-    @abstractmethod
-    def add_cost(self, cost_dict: dict[str, Any]) -> str:
-        """Register a new cost."""
-
-    def __post_init__(self, *args, **kwargs) -> None:  # noqa: ANN002, ANN003
-        """Allow post init configuration."""
-
-    @abstractmethod
-    def get(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        """Get a cost."""

digitalkin-0.2.10/src/digitalkin/services/cost/default_cost.py

@@ -1,30 +0,0 @@
-"""Default cost."""
-
-import logging
-from typing import Any
-
-from digitalkin.services.cost.cost_strategy import CostData, CostStrategy
-
-logger = logging.getLogger(__name__)
-
-
-class DefaultCost(CostStrategy):
-    """Default cost strategy."""
-
-    def add_cost(self, cost_dict: dict[str, Any]) -> str:  # noqa: PLR6301
-        """Create a new record in the cost database.
-
-        Returns:
-            str: The ID of the new record
-        """
-        logger.info("Cost added with cost_dict: %s", cost_dict)
-        return ""
-
-    def get(self, cost_dict: dict[str, Any]) -> list[CostData]:  # noqa: PLR6301
-        """Get records from the database.
-
-        Returns:
-            list[CostData]: The list of records
-        """
-        logger.info("Costs querried with cost_dict: %s", cost_dict)
-        return []

digitalkin-0.2.10/src/digitalkin/services/cost/grpc_cost.py

@@ -1,81 +0,0 @@
-"""This module implements the default Cost strategy."""
-
-import logging
-from typing import Any
-
-from digitalkin_proto.digitalkin.cost.v1 import cost_pb2, cost_service_pb2_grpc
-from google.protobuf import json_format
-from pydantic import ValidationError
-
-from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
-from digitalkin.grpc_servers.utils.models import ServerConfig
-from digitalkin.services.cost.cost_strategy import CostData, CostStrategy
-
-logger = logging.getLogger(__name__)
-
-
-class GrpcCost(CostStrategy, GrpcClientWrapper):
-    """This class implements the default Cost strategy."""
-
-    def _get_costs_by_name(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        request = cost_pb2.GetCostsByNameRequest(
-            mission_id=cost_dict["mission_id"],
-            name=cost_dict["name"],
-        )
-        response = self.exec_grpc_query("GetCostsByName", request)
-        return [CostData(**json_format.MessageToDict(cost)) for cost in response.costs]
-
-    def _get_costs_by_mission(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        request = cost_pb2.GetCostsByMissionRequest(mission_id=cost_dict["mission_id"])
-        response = self.exec_grpc_query("GetCostsByMission", request)
-        return [CostData(**json_format.MessageToDict(cost)) for cost in response.costs]
-
-    def _get_costs_by_type(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        request = cost_pb2.GetCostsByTypeRequest(
-            mission_id=cost_dict["mission_id"],
-            type=cost_dict["type"],
-        )
-        response = self.exec_grpc_query("GetCostsBytype", request)
-        return [CostData(**json_format.MessageToDict(cost)) for cost in response.costs]
-
-    def __init__(self, mission_id: str, config: ServerConfig) -> None:
-        """Initialize the cost."""
-        super().__init__(mission_id)
-        channel = self._init_channel(config)
-        self.stub = cost_service_pb2_grpc.CostServiceStub(channel)
-        logger.info("Channel client 'Cost' initialized succesfully")
-
-    def add_cost(self, cost_dict: dict[str, Any]) -> str:
-        """Create a new record in the cost database.
-
-        Required arguments:
-            data: Object representation of CostData
-
-        Returns:
-            str: The ID of the new record
-        """
-        try:
-            valid_data = CostData.model_validate(cost_dict["data"])
-        except ValidationError:
-            logger.exception("Validation failed for model StorageData")
-            return ""
-        except KeyError:
-            logger.exception("Missing mandatory 'data' in dict.")
-            return ""
-
-        request = cost_pb2.AddCostRequest(**valid_data.model_dump())
-        return self.exec_grpc_query("AddCost", request)
-
-    def get(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        """Get records from the database.
-
-        Returns:
-            list[CostData]: The list of records
-        """
-        if "mission_id" not in cost_dict:
-            return []
-        if "name" in cost_dict:
-            return self._get_costs_by_name(cost_dict)
-        if "type" in cost_dict:
-            return self._get_costs_by_type(cost_dict)
-        return self._get_costs_by_mission(cost_dict)