digitalkin 0.1.1__py3-none-any.whl

digitalkin/modules/tool_module.py

@@ -0,0 +1,14 @@
+"""ToolModule extends BaseModule to implement specific module types."""
+
+from abc import ABC
+
+from ._base_module import BaseModule
+
+
+class ToolModule(BaseModule, ABC):
+    """ToolModule extends BaseModule to implement specific module types."""
+
+    def __init__(self, metadata):
+        """Initialize the module with the given metadata."""
+        super().__init__(metadata)
+        self.capabilities = ["tool"]

digitalkin/modules/trigger_module.py

@@ -0,0 +1,14 @@
+"""TriggerModule extends BaseModule to implement specific module types."""
+
+from abc import ABC
+
+from ._base_module import BaseModule
+
+
+class TriggerModule(BaseModule, ABC):
+    """TriggerModule extends BaseModule to implement specific module types."""
+
+    def __init__(self, metadata):
+        """Initialize the module with the given metadata."""
+        super().__init__(metadata)
+        self.capabilities = ["trigger"]

digitalkin/services/__init__.py

@@ -0,0 +1,28 @@
+"""This package contains the abstract base class for all services."""
+
+from .agent import AgentStrategy, DefaultAgent
+from .cost import CostStrategy, DefaultCost
+from .filesystem import DefaultFilesystem, FilesystemStrategy
+from .identity import DefaultIdentity, IdentityStrategy
+from .registry import DefaultRegistry, RegistryStrategy
+from .service_provider import ServiceProvider
+from .snapshot import DefaultSnapshot, SnapshotStrategy
+from .storage import DefaultStorage, StorageStrategy
+
+__all__ = [
+    "AgentStrategy",
+    "CostStrategy",
+    "DefaultAgent",
+    "DefaultCost",
+    "DefaultFilesystem",
+    "DefaultIdentity",
+    "DefaultRegistry",
+    "DefaultSnapshot",
+    "DefaultStorage",
+    "FilesystemStrategy",
+    "IdentityStrategy",
+    "RegistryStrategy",
+    "ServiceProvider",
+    "SnapshotStrategy",
+    "StorageStrategy",
+]

digitalkin/services/agent/__init__.py

@@ -0,0 +1,6 @@
+"""This module is responsible for handling the agent services."""
+
+from .agent_strategy import AgentStrategy
+from .default_agent import DefaultAgent
+
+__all__ = ["AgentStrategy", "DefaultAgent"]

digitalkin/services/agent/agent_strategy.py

@@ -0,0 +1,22 @@
+"""This module contains the abstract base class for agent strategies."""
+
+from abc import ABC, abstractmethod
+
+
+class AgentStrategy(ABC):
+    """Abstract base class for agent strategies."""
+
+    @abstractmethod
+    def __init__(self) -> None:
+        """Initialize the agent strategy."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def start(self) -> None:
+        """Start the agent."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def stop(self) -> None:
+        """Stop the agent."""
+        raise NotImplementedError

digitalkin/services/agent/default_agent.py

@@ -0,0 +1,16 @@
+"""Default agent implementation for the agent service."""
+
+from .agent_strategy import AgentStrategy
+
+
+class DefaultAgent(AgentStrategy):
+    """Default agent implementation for the agent service."""
+
+    def __init__(self) -> None:
+        """Initialize the default agent."""
+
+    def start(self) -> None:
+        """Start the agent."""
+
+    def stop(self) -> None:
+        """Stop the agent."""

digitalkin/services/cost/__init__.py

@@ -0,0 +1,6 @@
+"""This module is responsible for handling the cost services."""
+
+from .cost_strategy import CostStrategy
+from .default_cost import DefaultCost
+
+__all__ = ["CostStrategy", "DefaultCost"]

digitalkin/services/cost/cost_strategy.py

@@ -0,0 +1,15 @@
+"""This module contains the abstract base class for cost strategies."""
+
+from abc import ABC, abstractmethod
+
+
+class CostStrategy(ABC):
+    """Abstract base class for cost strategies."""
+
+    @abstractmethod
+    def __init__(self) -> None:
+        """Initialize the cost strategy."""
+
+    @abstractmethod
+    def register_cost(self, data: dict[str, str]) -> None:
+        """Register a new cost."""

digitalkin/services/cost/default_cost.py

@@ -0,0 +1,13 @@
+"""Default cost."""
+
+from .cost_strategy import CostStrategy
+
+
+class DefaultCost(CostStrategy):
+    """Default cost strategy."""
+
+    def __init__(self) -> None:
+        """Initialize the cost strategy."""
+
+    def register_cost(self, data: dict[str, str]) -> None:
+        """Register a new cost."""

digitalkin/services/default_service.py

@@ -0,0 +1,13 @@
+"""Default entrypoint for a DigitalKin module's services."""
+
+from digitalkin.services.service_provider import ServiceProvider
+from digitalkin.services.storage.default_storage import DefaultStorage
+
+
+class DefaultServiceProvider(ServiceProvider):
+    """Service Instance used as default service in a Module.
+
+    Currently only allow the default (local) database service.
+    """
+
+    storage = DefaultStorage()

digitalkin/services/development_service.py

@@ -0,0 +1,10 @@
+"""Dev entrypoint for a DigitalKin module's services."""
+
+from digitalkin.services.service_provider import ServiceProvider
+from digitalkin.services.storage.grpc_storage import GrpcStorage
+
+
+class DevelopmentServiceProvider(ServiceProvider):
+    """Service Instance used as a development service in a Module."""
+
+    storage = GrpcStorage()

digitalkin/services/filesystem/__init__.py

@@ -0,0 +1,6 @@
+"""This module is responsible for handling the filesystem services."""
+
+from .default_filesystem import DefaultFilesystem
+from .filesystem_strategy import FilesystemStrategy
+
+__all__ = ["DefaultFilesystem", "FilesystemStrategy"]

digitalkin/services/filesystem/default_filesystem.py

@@ -0,0 +1,29 @@
+"""Default filesystem."""
+
+from typing import Any
+
+from .filesystem_strategy import FilesystemStrategy
+
+
+class DefaultFilesystem(FilesystemStrategy):
+    """Default state filesystem strategy."""
+
+    def create(self, data: dict[str, Any]) -> str:
+        """Create a new file in the file system."""
+        raise NotImplementedError
+
+    def get(self, data: dict[str, Any]) -> list[dict[str, Any]]:
+        """Get files from the file system."""
+        raise NotImplementedError
+
+    def update(self, data: dict[str, Any]) -> int:
+        """Update files in the file system."""
+        raise NotImplementedError
+
+    def delete(self, data: dict[str, Any]) -> int:
+        """Delete files from the file system."""
+        raise NotImplementedError
+
+    def get_all(self) -> list[dict[str, Any]]:
+        """Get all files from the file system."""
+        raise NotImplementedError

digitalkin/services/filesystem/filesystem_strategy.py

@@ -0,0 +1,31 @@
+"""This module contains the abstract base class for filesystem strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class FilesystemStrategy(ABC):
+    """Abstract base class for file system strategies."""
+
+    def __init__(self) -> None:
+        """Initialize the file system strategy."""
+
+    @abstractmethod
+    def create(self, data: dict[str, Any]) -> str:
+        """Create a new file in the file system."""
+
+    @abstractmethod
+    def get(self, data: dict[str, Any]) -> list[dict[str, Any]]:
+        """Get files from the file system."""
+
+    @abstractmethod
+    def update(self, data: dict[str, Any]) -> int:
+        """Update files in the file system."""
+
+    @abstractmethod
+    def delete(self, data: dict[str, Any]) -> int:
+        """Delete files from the file system."""
+
+    @abstractmethod
+    def get_all(self) -> list[dict[str, Any]]:
+        """Get all files from the file system."""

digitalkin/services/identity/__init__.py

@@ -0,0 +1,6 @@
+"""This module is responsible for handling the identity service."""
+
+from .default_identity import DefaultIdentity
+from .identity_strategy import IdentityStrategy
+
+__all__ = ["DefaultIdentity", "IdentityStrategy"]

digitalkin/services/identity/default_identity.py

@@ -0,0 +1,15 @@
+"""Default identity."""
+
+from .identity_strategy import IdentityStrategy
+
+
+class DefaultIdentity(IdentityStrategy):
+    """DefaultIdentity is the default identity strategy."""
+
+    async def get_identity(self) -> str:  # noqa: PLR6301
+        """Get the identity.
+
+        Returns:
+            str: The identity
+        """
+        return "default_identity"

digitalkin/services/identity/identity_strategy.py

@@ -0,0 +1,12 @@
+"""This module contains the abstract base class for identity strategies."""
+
+from abc import ABC, abstractmethod
+
+
+class IdentityStrategy(ABC):
+    """IdentityStrategy is the abstract base class for all identity strategies."""
+
+    @abstractmethod
+    async def get_identity(self) -> str:
+        """Get the identity."""
+        raise NotImplementedError

digitalkin/services/registry/__init__.py

@@ -0,0 +1,6 @@
+"""This module is responsible for handling the registry service."""
+
+from .default_registry import DefaultRegistry
+from .registry_strategy import RegistryStrategy
+
+__all__ = ["DefaultRegistry", "RegistryStrategy"]

digitalkin/services/registry/default_registry.py

@@ -0,0 +1,13 @@
+"""Default registry."""
+
+from .registry_strategy import RegistryStrategy
+
+
+class DefaultRegistry(RegistryStrategy):
+    """Default registry strategy."""
+
+    def __init__(self) -> None:
+        """Initialize the registry strategy."""
+
+    def get_by_id(self, module_id: str) -> None:
+        """Get services from the registry."""

digitalkin/services/registry/registry_strategy.py

@@ -0,0 +1,17 @@
+"""This module contains the abstract base class for registry strategies."""
+
+from abc import ABC, abstractmethod
+
+
+class RegistryStrategy(ABC):
+    """Abstract base class for registry strategies."""
+
+    @abstractmethod
+    def __init__(self) -> None:
+        """Initialize the registry strategy."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_by_id(self, module_id: str) -> None:
+        """Get services from the registry."""
+        raise NotImplementedError

digitalkin/services/service_provider.py

@@ -0,0 +1,27 @@
+"""Service Provider definitions."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel
+
+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 ServiceProvider(BaseModel):
+    """Service class describing the available services in a Module."""
+
+    storage: ClassVar[StorageStrategy]
+    cost: ClassVar[CostStrategy]
+    snapshot: ClassVar[SnapshotStrategy]
+    registry: ClassVar[RegistryStrategy]
+    filesystem: ClassVar[FilesystemStrategy]
+    agent: ClassVar[AgentStrategy]
+    identity: ClassVar[IdentityStrategy]
+
+    model_config = {"arbitrary_types_allowed": True}

digitalkin/services/snapshot/__init__.py

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

digitalkin/services/snapshot/default_snapshot.py

@@ -0,0 +1,39 @@
+"""Default snapshot."""
+
+from typing import Any
+
+from .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,31 @@
+"""This module contains the abstract base class for snapshot strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class SnapshotStrategy(ABC):
+    """Abstract base class for snapshot strategies."""
+
+    def __init__(self) -> None:
+        """Initialize the snapshot strategy."""
+
+    @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,6 @@
+"""This module is responsible for handling the storage service."""
+
+from .default_storage import DefaultStorage
+from .storage_strategy import StorageStrategy
+
+__all__ = ["DefaultStorage", "StorageStrategy"]

digitalkin/services/storage/default_storage.py

@@ -0,0 +1,91 @@
+"""This module implements the default storage strategy."""
+
+import logging
+from typing import Any
+
+from .storage_strategy import StorageStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class DefaultStorage(StorageStrategy):
+    """This class implements the default storage strategy."""
+
+    storage: dict[str, list[dict[str, Any]]]
+
+    def __init__(self) -> None:
+        """Initialize the default storage strategy."""
+        super().__init__()
+        self.storage = {"setups": []}
+
+    def connect(self) -> bool:  # noqa: PLR6301
+        """Establish connection to the database.
+
+        Returns:
+            bool: True if the connection is successful, False otherwise
+        """
+        return True
+
+    def disconnect(self) -> bool:  # noqa: PLR6301
+        """Close connection to the database.
+
+        Returns:
+            bool: True if the connection is closed, False otherwise
+        """
+        return True
+
+    def create(self, table: str, data: dict[str, Any]) -> str:
+        """Create a new record in the database.
+
+        Returns:
+            str: The ID of the new record
+        """
+        if table not in self.storage:
+            self.storage[table] = []
+        self.storage[table].append(data["data"])
+        logger.info("CREATE %s:%s succesfull", table, data["data"])
+        return f"{len(self.storage[table]) - 1}"
+
+    def get(self, table: str, data: dict[str, Any]) -> list[dict[str, Any]]:
+        """Get records from the database.
+
+        Returns:
+            list[dict[str, Any]]: The list of records
+        """
+        logger.info("GET table = %s: keys = %s", table, data["keys"])
+        if table not in self.storage:
+            logger.info("GET table = %s: TABLE DOESN'T EXIST", table)
+            return []
+        return [self.storage[table][int(key)] for key in data["keys"]]
+
+    def update(self, table: str, data: dict[str, Any]) -> int:
+        """Update records in the database.
+
+        Returns:
+            int: The number of records updated
+        """
+        if table not in self.storage:
+            logger.info("UPDATE table = %s: TABLE DOESN'T EXIST", table)
+            return 0
+        self.storage[table][data["update_id"]] = data["update_value"]
+        return 1
+
+    def delete(self, table: str, data: dict[str, Any]) -> int:
+        """Delete records from the database.
+
+        Returns:
+            int: The number of records deleted
+        """
+        if table not in self.storage:
+            logger.info("UPDATE table = %s: TABLE DOESN'T EXIST", table)
+            return 0
+        del self.storage[table][data["delete_id"]]
+        return 1
+
+    def get_all(self) -> dict[str, list[dict[str, Any]]]:
+        """Get all records from the database.
+
+        Returns:
+            dict[str, list[dict[str, Any]]]: table with respective list of records
+        """
+        return self.storage