digitalkin 0.2.26__py3-none-any.whl → 0.3.0.dev1__py3-none-any.whl

digitalkin/mixins/logger_mixin.py

@@ -0,0 +1,59 @@
+"""Logger Mixin to ease and merge every logs."""
+
+from digitalkin.models.module.module_context import ModuleContext
+
+
+class LoggerMixin:
+    """Mixin providing callback operations through the callbacks strategy.
+
+    This mixin wraps callback strategy calls to provide a cleaner API
+    for logging and messaging in trigger handlers.
+    """
+
+    @staticmethod
+    def log_debug(context: ModuleContext, message: str) -> None:
+        """Log debug message using the callbacks strategy.
+
+        Args:
+            context: Module context containing the callbacks strategy
+            message: Debug message to log
+            *args: Positional arguments for message formatting
+            **kwargs: Keyword arguments for logger
+        """
+        return context.callbacks.logger.debug(message)
+
+    @staticmethod
+    def log_info(context: ModuleContext, message: str) -> None:
+        """Log info message using the callbacks strategy.
+
+        Args:
+            context: Module context containing the callbacks strategy
+            message: Info message to log
+            *args: Positional arguments for message formatting
+            **kwargs: Keyword arguments for logger
+        """
+        return context.callbacks.logger.info(message)
+
+    @staticmethod
+    def log_warning(context: ModuleContext, message: str) -> None:
+        """Log warning message using the callbacks strategy.
+
+        Args:
+            context: Module context containing the callbacks strategy
+            message: Warning message to log
+            *args: Positional arguments for message formatting
+            **kwargs: Keyword arguments for logger
+        """
+        return context.callbacks.logger.warning(message)
+
+    @staticmethod
+    def log_error(context: ModuleContext, message: str) -> None:
+        """Log error message using the callbacks strategy.
+
+        Args:
+            context: Module context containing the callbacks strategy
+            message: Error message to log
+            *args: Positional arguments for message formatting
+            **kwargs: Keyword arguments for logger
+        """
+        return context.callbacks.logger.error(message)

digitalkin/mixins/storage_mixin.py

@@ -0,0 +1,79 @@
+"""Storage Mixin to ease storage access in Triggers."""
+
+from typing import Any, Literal
+
+from digitalkin.models.module.module_context import ModuleContext
+from digitalkin.services.storage.storage_strategy import StorageRecord
+
+
+class StorageMixin:
+    """Mixin providing storage operations through the storage strategy.
+
+    This mixin wraps storage strategy calls to provide a cleaner API
+    for trigger handlers.
+    """
+
+    @staticmethod
+    def store_storage(
+        context: ModuleContext,
+        collection: str,
+        record_id: str | None,
+        data: dict[str, Any],
+        data_type: Literal["OUTPUT", "VIEW", "LOGS", "OTHER"] = "OUTPUT",
+    ) -> StorageRecord:
+        """Store data using the storage strategy.
+
+        Args:
+            context: Module context containing the storage strategy
+            collection: Collection name for the data
+            record_id: Optional record identifier
+            data: Data to store
+            data_type: Type of data being stored
+
+        Returns:
+            Result from the storage strategy
+
+        Raises:
+            StorageServiceError: If storage operation fails
+        """
+        return context.storage.store(collection, record_id, data, data_type=data_type)
+
+    @staticmethod
+    def read_storage(context: ModuleContext, collection: str, record_id: str) -> StorageRecord | None:
+        """Read data from storage.
+
+        Args:
+            context: Module context containing the storage strategy
+            collection: Collection name
+            record_id: Record identifier
+
+        Returns:
+            Retrieved data
+
+        Raises:
+            StorageServiceError: If read operation fails
+        """
+        return context.storage.read(collection, record_id)
+
+    @staticmethod
+    def update_storage(
+        context: ModuleContext,
+        collection: str,
+        record_id: str,
+        data: dict[str, Any],
+    ) -> StorageRecord | None:
+        """Update existing data in storage.
+
+        Args:
+            context: Module context containing the storage strategy
+            collection: Collection name
+            record_id: Record identifier
+            data: Updated data
+
+        Returns:
+            Result from the storage strategy
+
+        Raises:
+            StorageServiceError: If update operation fails
+        """
+        return context.storage.update(collection, record_id, data)

digitalkin/models/module/__init__.py

@@ -5,6 +5,7 @@ from digitalkin.models.module.module_context import ModuleContext
 from digitalkin.models.module.module_types import (
     DataModel,
     DataTrigger,
+    DataTriggerT,
     InputModelT,
     OutputModelT,
     SecretModelT,
@@ -15,6 +16,7 @@ from digitalkin.models.module.module_types import (
 __all__ = [
     "DataModel",
     "DataTrigger",
+    "DataTriggerT",
     "InputModelT",
     "Module",
     "ModuleContext",

digitalkin/models/module/module.py

@@ -2,7 +2,15 @@
 
 from enum import Enum, auto
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+
+
+class ModuleCodeModel(BaseModel):
+    """typed error/code model."""
+
+    code: str = Field(...)
+    message: str | None = Field(default=None)
+    short_description: str | None = Field(default=None)
 
 
 class ModuleStatus(Enum):

digitalkin/models/module/module_context.py

@@ -1,24 +1,108 @@
 """Define the module context used in the triggers."""
 
 from types import SimpleNamespace
+from typing import Any
 
+from digitalkin.services.agent.agent_strategy import AgentStrategy
 from digitalkin.services.cost.cost_strategy import CostStrategy
 from digitalkin.services.filesystem.filesystem_strategy import FilesystemStrategy
+from digitalkin.services.identity.identity_strategy import IdentityStrategy
+from digitalkin.services.registry.registry_strategy import RegistryStrategy
+from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 from digitalkin.services.storage.storage_strategy import StorageStrategy
 
 
-class ModuleContext(SimpleNamespace):
-    """ModuleContext provides a container for strategies and resources used by a module.
+class Session(SimpleNamespace):
+    """Session data container with mandatory setup_id and mission_id."""
+
+    mission_id: str
+    setup_version_id: str
+
+    def __init__(self, mission_id: str, setup_version_id: str, **kwargs: dict[str, Any]) -> None:
+        """Init Module Session.
+
+        Args:
+            mission_id: current mission_id.
+            setup_version_id: used setup config.
+            kwargs: user defined session variables.
+
+        Raises:
+            ValueError: If mandatory args are missing
+        """
+        if not setup_version_id:
+            msg = "setup_version_id is mandatory and cannot be empty"
+            raise ValueError(msg)
+        if not mission_id:
+            msg = "mission_id is mandatory and cannot be empty"
+            raise ValueError(msg)
+
+        self.mission_id = mission_id
+        self.setup_version_id = setup_version_id
+
+        super().__init__(**kwargs)
 
-    Attributes:
-        cost (CostStrategy): The strategy used to calculate or manage costs within the module.
-        filesystem (FilesystemStrategy): The strategy for interacting with the filesystem.
-        storage (StorageStrategy): The strategy for handling storage operations.
+
+class ModuleContext:
+    """ModuleContext provides a container for strategies and resources used by a module.
 
     This context object is designed to be passed to module components, providing them with
     access to shared strategies and resources. Additional attributes may be set dynamically.
     """
 
+    # services list
+    agent: AgentStrategy
     cost: CostStrategy
     filesystem: FilesystemStrategy
+    identity: IdentityStrategy
+    registry: RegistryStrategy
+    snapshot: SnapshotStrategy
     storage: StorageStrategy
+
+    session: Session
+    callbacks: SimpleNamespace
+    metadata: SimpleNamespace
+    helpers: SimpleNamespace
+    state: SimpleNamespace = SimpleNamespace()
+
+    def __init__(  # noqa: PLR0913, PLR0917
+        self,
+        agent: AgentStrategy,
+        cost: CostStrategy,
+        filesystem: FilesystemStrategy,
+        identity: IdentityStrategy,
+        registry: RegistryStrategy,
+        snapshot: SnapshotStrategy,
+        storage: StorageStrategy,
+        session: dict[str, Any],
+        metadata: dict[str, Any] = {},
+        helpers: dict[str, Any] = {},
+        callbacks: dict[str, Any] = {},
+    ) -> None:
+        """Register mandatory services, session, metadata and callbacks.
+
+        Args:
+            agent: AgentStrategy.
+            cost: CostStrategy.
+            filesystem: FilesystemStrategy.
+            identity: IdentityStrategy.
+            registry: RegistryStrategy.
+            snapshot: SnapshotStrategy.
+            storage: StorageStrategy.
+            metadata: dict defining differents Module metadata.
+            helpers: dict different user defined helpers.
+            session: dict referring the session IDs or informations.
+            callbacks: Functions allowing user to agent interaction.
+        """
+        # Core services
+        self.agent = agent
+        self.cost = cost
+        self.filesystem = filesystem
+        self.identity = identity
+        self.registry = registry
+        self.snapshot = snapshot
+        self.storage = storage
+
+        self.metadata = SimpleNamespace(**metadata)
+        self.session = Session(**session)
+        self.helpers = SimpleNamespace(**helpers)
+        self.callbacks = SimpleNamespace(**callbacks)

digitalkin/models/module/module_types.py

@@ -9,9 +9,9 @@ from digitalkin.logger import logger
 
 
 class DataTrigger(BaseModel):
-    """Defines the root input model exposing the protocol.
+    """Defines the root input/output model exposing the protocol.
 
-    The mandatory protocol is important to define the module beahvior following the user or agent input.
+    The mandatory protocol is important to define the module beahvior following the user or agent input/output.
 
     Example:
         class MyInput(DataModel):
@@ -24,16 +24,16 @@ class DataTrigger(BaseModel):
     """
 
     protocol: ClassVar[str]
-    created_at: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    created_at: str = datetime.now(tz=timezone.utc).isoformat()
 
 
 DataTriggerT = TypeVar("DataTriggerT", bound=DataTrigger)
 
 
 class DataModel(BaseModel, Generic[DataTriggerT]):
-    """Base definition of input model showing mandatory root fields.
+    """Base definition of input/output model showing mandatory root fields.
 
-    The Model define the Module Input, usually referring to multiple input type defined by an union.
+    The Model define the Module Input/output, usually referring to multiple input/output type defined by an union.
 
     Example:
         class ModuleInput(DataModel):
@@ -102,4 +102,4 @@ class SetupModel(BaseModel):
             __config__=ConfigDict(arbitrary_types_allowed=True),
             **clean_fields,
         )
-        return cast("type[SetupModelT]", m)
+        return cast("type[SetupModelT]", m)  # type: ignore

digitalkin/models/module/task_monitor.py

@@ -0,0 +1,51 @@
+"""."""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class TaskStatus(Enum):
+    """."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class SignalType(Enum):
+    """."""
+
+    START = "start"
+    STOP = "stop"
+    CANCEL = "cancel"
+    PAUSE = "pause"
+    RESUME = "resume"
+    STATUS = "status"
+
+    ACK_CANCEL = "ack_cancel"
+    ACK_PAUSE = "ack_pause"
+    ACK_RESUME = "ack_resume"
+    ACK_STATUS = "ack_status"
+
+
+class SignalMessage(BaseModel):
+    """."""
+
+    task_id: str = Field(..., description="Unique identifier for the task")
+    status: TaskStatus = Field(..., description="Current status of the task")
+    action: SignalType = Field(..., description="Type of signal action")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    payload: dict[str, Any] = Field(default={}, description="Optional payload for the signal")
+    model_config = {"use_enum_values": True}
+
+
+class HeartbeatMessage(BaseModel):
+    """."""
+
+    task_id: str = Field(..., description="Unique identifier for the task")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))

digitalkin/models/services/__init__.py

@@ -1 +1,10 @@
 """This module contains the models for the services."""
+
+from digitalkin.models.services.storage import BaseMessage, BaseRole, ChatHistory, Role
+
+__all__ = [
+    "BaseMessage",
+    "BaseRole",
+    "ChatHistory",
+    "Role",
+]

digitalkin/models/services/storage.py

@@ -1,10 +1,44 @@
 """Storage model."""
 
-from pydantic import BaseModel
+from enum import Enum
+from typing import Any
 
+from pydantic import BaseModel, Field
 
-class StorageModel(BaseModel):
-    """Storage model."""
 
-    data: object
-    type: str
+class BaseRole(str, Enum):
+    """Officially supported Role Enum for chat messages."""
+
+    ASSISTANT = "assistant"
+    HUMAN = "human"
+    SYSTEM = "system"
+
+
+Role = BaseRole | str
+
+
+class BaseMessage(BaseModel):
+    """Base Model representing a simple message in the chat history."""
+
+    role: Role = Field(..., description="Role of the message sender")
+    content: Any = Field(..., description="The content of the message | preferably a BaseModel.")
+
+
+class ChatHistory(BaseModel):
+    """Storage chat history model for the OpenAI Archetype module."""
+
+    messages: list[BaseMessage] = Field(..., description="List of messages in the chat history")
+
+
+class FileModel(BaseModel):
+    """File model."""
+
+    file_id: str = Field(..., description="ID of the file")
+    name: str = Field(..., description="Name of the file")
+    metadata: dict[str, Any] = Field(..., description="Metadata of the file")
+
+
+class FileHistory(BaseModel):
+    """File history model."""
+
+    files: list[FileModel] = Field(..., description="List of files")