digitalkin 0.2.16__tar.gz → 0.2.17__tar.gz

{digitalkin-0.2.16 → digitalkin-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.16
+Version: 0.2.17
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-0.2.16 → digitalkin-0.2.17}/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.16"
+    version = "0.2.17"
 
     classifiers = [
         "Development Status :: 3 - Alpha",
@@ -212,7 +212,7 @@
                 "ANN401",
                 "PLR0912",
                 "ANN201",
-                "D100"
+                "D100",
             ]
 
         [tool.ruff.lint.pylint]

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin/__version__.py

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

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin/grpc_servers/module_server.py

@@ -79,10 +79,10 @@ class ModuleServer(BaseServer):
 
     def start(self) -> None:
         """Start the module server and register with the registry if configured."""
-        logger.critical(self.server_config)
+        logger.info(self.server_config)
         super().start()
 
-        logger.critical(self.server_config)
+        logger.info(self.server_config)
         # If a registry address is provided, register the module
         if self.server_config.registry_address:
             try:
@@ -91,17 +91,17 @@ class ModuleServer(BaseServer):
                 logger.exception("Failed to register with registry")
 
         if self.module_servicer is not None:
-            logger.critical(
+            logger.info(
                 "Setup post init started with config: %s", self.client_config
             )
             self.module_servicer.setup.__post_init__(self.client_config)
 
     async def start_async(self) -> None:
         """Start the module server and register with the registry if configured."""
-        logger.critical(self.server_config)
+        logger.info(self.server_config)
         await super().start_async()
 
-        logger.critical(self.server_config)
+        logger.info(self.server_config)
         # If a registry address is provided, register the module
         if self.server_config.registry_address:
             try:
@@ -110,7 +110,7 @@ class ModuleServer(BaseServer):
                 logger.exception("Failed to register with registry")
 
         if self.module_servicer is not None:
-            logger.critical(
+            logger.info(
                 "Setup post init started with config: %s", self.client_config
             )
             await self.module_servicer.job_manager._start()

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin/grpc_servers/module_servicer.py

@@ -70,6 +70,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             module_class: The module type to serve.
         """
         super().__init__()
+        module_class.discover()
         self.module_class = module_class
         job_manager_class = self.args.job_manager_mode.get_manager_class()
         self.job_manager = job_manager_class(module_class, self.args.services_mode)

digitalkin-0.2.17/src/digitalkin/models/module/__init__.py

@@ -0,0 +1,26 @@
+"""This module contains the models for the modules."""
+
+from digitalkin.models.module.module import Module, ModuleStatus
+from digitalkin.models.module.module_context import ModuleContext
+from digitalkin.models.module.module_types import (
+    ConfigSetupModelT,
+    InputModel,
+    InputModelT,
+    InputTrigger,
+    OutputModelT,
+    SecretModelT,
+    SetupModelT,
+)
+
+__all__ = [
+    "ConfigSetupModelT",
+    "InputModel",
+    "InputModelT",
+    "InputTrigger",
+    "Module",
+    "ModuleContext",
+    "ModuleStatus",
+    "OutputModelT",
+    "SecretModelT",
+    "SetupModelT",
+]

digitalkin-0.2.17/src/digitalkin/models/module/module_context.py

@@ -0,0 +1,24 @@
+"""Define the module context used in the triggers."""
+
+from types import SimpleNamespace
+
+from digitalkin.services.cost.cost_strategy import CostStrategy
+from digitalkin.services.filesystem.filesystem_strategy import FilesystemStrategy
+from digitalkin.services.storage.storage_strategy import StorageStrategy
+
+
+class ModuleContext(SimpleNamespace):
+    """ModuleContext provides a container for strategies and resources used by a module.
+
+    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.
+
+    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.
+    """
+
+    cost: CostStrategy
+    filesystem: FilesystemStrategy
+    storage: StorageStrategy

digitalkin-0.2.17/src/digitalkin/models/module/module_types.py

@@ -0,0 +1,43 @@
+"""Types for module models."""
+
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+
+class InputTrigger(BaseModel):
+    """Defines the root input model exposing the protocol.
+
+    The mandatory protocol is important to define the module beahvior following the user or agent input.
+
+    Example:
+        class MyInput(InputModel):
+            root: InputTrigger
+            user_define_data: Any
+
+        # Usage
+        my_input = MyInput(root=InputTrigger(protocol="message"))
+        print(my_input.root.protocol)  # Output: message
+    """
+
+    protocol: str
+
+
+class InputModel(BaseModel):
+    """Base definition of input model showing mandatory root fields.
+
+    The Model define the Module Input, usually referring to multiple input type defined by an union.
+
+    Example:
+        class ModuleInput(InputModel):
+            root: FileInput | MessageInput
+    """
+
+    root: InputTrigger
+
+
+ConfigSetupModelT = TypeVar("ConfigSetupModelT", bound=BaseModel | None)
+InputModelT = TypeVar("InputModelT", bound=InputModel)
+OutputModelT = TypeVar("OutputModelT", bound=BaseModel)
+SetupModelT = TypeVar("SetupModelT", bound=BaseModel)
+SecretModelT = TypeVar("SecretModelT", bound=BaseModel)

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin/modules/__init__.py

@@ -2,6 +2,6 @@
 
 from digitalkin.modules.archetype_module import ArchetypeModule
 from digitalkin.modules.tool_module import ToolModule
-from digitalkin.modules.trigger_module import TriggerModule
+from digitalkin.modules.trigger_handler import TriggerHandler
 
-__all__ = ["ArchetypeModule", "ToolModule", "TriggerModule"]
+__all__ = ["ArchetypeModule", "ToolModule", "TriggerHandler"]

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin/modules/_base_module.py

@@ -19,6 +19,8 @@ from digitalkin.models.module import (
     SecretModelT,
     SetupModelT,
 )
+from digitalkin.models.module.module_context import ModuleContext
+from digitalkin.modules.trigger_handler import TriggerHandler
 from digitalkin.services.agent.agent_strategy import AgentStrategy
 from digitalkin.services.cost.cost_strategy import CostStrategy
 from digitalkin.services.filesystem.filesystem_strategy import FilesystemStrategy
@@ -28,17 +30,18 @@ from digitalkin.services.services_config import ServicesConfig, ServicesStrategy
 from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 from digitalkin.services.storage.storage_strategy import StorageStrategy
 from digitalkin.utils.llm_ready_schema import llm_ready_schema
+from digitalkin.utils.package_discover import ModuleDiscoverer
 
 
 class ModuleErrorModel(BaseModel):
-    """Typed error/code model."""
+    """typed error/code model."""
 
     code: str
     exception: str
     short_description: str
 
 
-class BaseModule(
+class BaseModule(  # noqa: PLR0904
     ABC,
     Generic[
         InputModelT,
@@ -60,6 +63,9 @@ class BaseModule(
     secret_format: type[SecretModelT]
     metadata: ClassVar[dict[str, Any]]
 
+    context: ModuleContext
+    triggers_discoverer: ClassVar[ModuleDiscoverer]
+
     # service config params
     services_config_strategies: ClassVar[dict[str, ServicesStrategy | None]]
     services_config_params: ClassVar[dict[str, dict[str, Any | None] | None]]
@@ -95,6 +101,13 @@ class BaseModule(
         # Initialize services configuration
         self._init_strategies()
 
+        # Initialize minimum context
+        self.context = ModuleContext(
+            storage=self.storage,
+            cost=self.cost,
+            filesystem=self.filesystem,
+        )
+
     @property
     def status(self) -> ModuleStatus:
         """Get the module status.
@@ -165,10 +178,12 @@ class BaseModule(
         Returns:
             The JSON schema of the config setup format as a string.
         """
-        if cls.config_setup_format is not None:
+        config_setup_format = getattr(cls, "config_setup_format", None)
+
+        if config_setup_format is not None:
             if llm_format:
-                return json.dumps(llm_ready_schema(cls.config_setup_format), indent=2)
-            return json.dumps(cls.config_setup_format.model_json_schema(), indent=2)
+                return json.dumps(llm_ready_schema(config_setup_format), indent=2)
+            return json.dumps(config_setup_format.model_json_schema(), indent=2)
         msg = "'%s' class does not define an 'config_setup_format'."
         raise OptionalFeatureNotImplementedError(msg)
 
@@ -249,6 +264,32 @@ class BaseModule(
         """
         return cls.output_format(**output_data)
 
+    @classmethod
+    def discover(cls) -> None:
+        """Discover and register all TriggerHandler subclasses in the specified package or current directory.
+
+        Dynamically import all Python modules in the specified package or current directory,
+        triggering class registrations for subclasses of TriggerHandler whose names end with 'Trigger'.
+
+        If a package is provided, all .py files within its path are imported; otherwise, the current
+        working directory is searched. For each imported module, any class matching the criteria is
+        registered via cls.register(). Errors during import are logged at debug level.
+        """
+        cls.triggers_discoverer.discover_modules()
+        logger.debug("discovered: %s", cls.triggers_discoverer)
+
+    @classmethod
+    def register(cls, handler_cls: type[TriggerHandler]) -> type[TriggerHandler]:
+        """Dynamically register the trigger class.
+
+        Args:
+            handler_cls: type of the trigger handler to register.
+
+        Returns:
+            type of the trigger handler.
+        """
+        return cls.triggers_discoverer.register_trigger(handler_cls)
+
     @abstractmethod
     async def run_config_setup(
         self,
@@ -269,15 +310,42 @@ class BaseModule(
         """Initialize the module."""
         raise NotImplementedError
 
-    @abstractmethod
     async def run(
         self,
         input_data: InputModelT,
         setup_data: SetupModelT,
         callback: Callable[[OutputModelT], Coroutine[Any, Any, None]],
     ) -> None:
-        """Run the module."""
-        raise NotImplementedError
+        """Run the module with the given input and setup data.
+
+        This method validates the input data, determines the protocol from the input,
+        and dispatches the request to the corresponding trigger handler. The trigger handler
+        is responsible for processing the input and invoking the callback with the result.
+
+        Triggers:
+            - The method is triggered when a module run is requested with specific input and setup data.
+            - The protocol specified in the input determines which trigger handler is invoked.
+
+        Args:
+            input_data (InputModelT): The input data to be processed by the module.
+            setup_data (SetupModelT): The setup or configuration data required for the module.
+            callback (Callable[[OutputModelT], Coroutine[Any, Any, None]]): callback to be invoked to stream any result.
+
+        Raises:
+            ValueError: If no handler for the protocol is found.
+        """
+        input_instance = self.input_format.model_validate(input_data)
+        handler_instance = self.triggers_discoverer.get_trigger(
+            input_instance.root.protocol,
+            input_instance.root,
+        )
+
+        await handler_instance.handle(
+            input_instance.root,
+            setup_data,
+            callback,
+            self.context,
+        )
 
     @abstractmethod
     async def cleanup(self) -> None:
@@ -338,6 +406,8 @@ class BaseModule(
             return
 
         try:
+            logger.info("Init the discod input handlers.")
+            self.triggers_discoverer.init_handlers(self.context)
             logger.info("Run lifecycle")
             self._status = ModuleStatus.RUNNING
             self._task = asyncio.create_task(

digitalkin-0.2.17/src/digitalkin/modules/trigger_handler.py

@@ -0,0 +1,47 @@
+"""Definition of the Trigger type."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Coroutine
+from typing import Any, ClassVar, Generic
+
+from digitalkin.models.module.module_types import InputModelT, OutputModelT, SetupModelT
+from digitalkin.modules._base_module import ModuleContext
+
+
+class TriggerHandler(ABC, Generic[InputModelT, SetupModelT, OutputModelT]):
+    """Base class for all input-trigger handlers.
+
+    Each handler declares:
+      - protocol_key: the Literal value this handler processes
+      - handle(): logic to process the validated payload
+    """
+
+    protocol: ClassVar[str]
+    input_format: type[InputModelT]
+    output_format: type[OutputModelT]
+
+    def __init__(self, context: ModuleContext) -> None:
+        """Initialize the TriggerHandler with the given context."""
+
+    @abstractmethod
+    async def handle(
+        self,
+        input_data: InputModelT,
+        setup_data: SetupModelT,
+        callback: Callable[[Any], Coroutine[Any, Any, None]],
+        context: ModuleContext,
+    ) -> None:
+        """Asynchronously processes the input data specific to Handler and streams results via the provided callback.
+
+        Args:
+            input_data (InputModelT): The input data to be processed by the handler.
+            setup_data (SetupModelT): The setup or configuration data required for processing.
+            callback (Callable[[Any], Coroutine[Any, Any, None]]): callback that stream results.
+            context (ModuleContext): The context object containing module-specific information and resources.
+
+        Returns:
+            Any: The result of the processing, if applicable.
+
+        Note:
+            The callback must be awaited to ensure results are streamed correctly during processing.
+        """

digitalkin-0.2.17/src/digitalkin/utils/package_discover.py

@@ -0,0 +1,358 @@
+"""."""
+
+import importlib
+import importlib.util
+import logging
+import pkgutil
+import sys
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import ClassVar
+
+from digitalkin.models.module.module_context import ModuleContext
+from digitalkin.models.module.module_types import InputTrigger
+from digitalkin.modules.trigger_handler import TriggerHandler
+
+logger = logging.getLogger(__name__)
+
+
+class SecurityError(Exception):
+    """Raised when security constraints are violated."""
+
+
+class DiscoveryError(Exception):
+    """Raised when discovery fails due to invalid inputs."""
+
+
+class ModuleDiscoverer:
+    """Encapsulates secure, structured discovery and import of trigger modules.
+
+    Attributes:
+        packages: List of Python package paths to scan.
+        file_pattern: Glob pattern to match module filenames.
+        safe_mode: If True, skips unsafe imports.
+        max_file_size: Maximum file size allowed for import (bytes).
+    """
+
+    FORBIDDEN_MODULE_PATTERNS: ClassVar[set[str]] = {
+        "__pycache__",
+        ".pyc",
+        ".pyo",
+        ".pyd",
+        "test_",
+        "_test",
+        "conftest",
+    }
+
+    trigger_handlers: ClassVar[dict[str, tuple[TriggerHandler, ...]]] = {}
+    _trigger_handlers_cls: ClassVar[dict[str, list[type[TriggerHandler]]]] = {}
+
+    def _validate_inputs(self) -> None:
+        """Validate initial discovery inputs.
+
+        Raises:
+            DiscoveryError: If packages list is invalid.
+            SecurityError: If file pattern or package names are unsafe.
+        """
+        if not self.packages or not isinstance(self.packages, list):
+            msg = "Packages must be a non-empty list"
+            raise DiscoveryError(msg)
+        self._validate_file_pattern()
+        for pkg in self.packages:
+            self._validate_package_name(pkg)
+
+    def _discover_package(self, package_name: str) -> dict[str, bool]:
+        """Import a package and scan its __path__ for modules.
+
+        Args:
+            package_name: Dotted path of the package to scan.
+
+        Returns:
+            Mapping of module names to import status.
+        """
+        try:
+            pkg = importlib.import_module(package_name)
+        except ImportError:
+            logger.exception("Could not import package %s", package_name)
+            return {}
+
+        paths = getattr(pkg, "__path__", None)
+        if not paths:
+            logger.warning("Package %s has no __path__", package_name)
+            return {}
+
+        results: dict[str, bool] = {}
+        for path_str in paths:
+            base_path = Path(path_str).resolve()
+            results.update(self._discover_in_path(package_name, base_path))
+        return results
+
+    def _discover_in_path(self, package_name: str, base_path: Path) -> dict[str, bool]:
+        """Walk a filesystem path to locate and process modules.
+
+        Args:
+            package_name: Root package name for prefixing.
+            base_path: Filesystem path of the package.
+
+        Returns:
+            Mapping of module names to import status.
+        """
+        results: dict[str, bool] = {}
+        if not base_path.is_dir():
+            logger.warning("Invalid package path: %s", base_path)
+            return results
+
+        for _, module_name, is_pkg in pkgutil.walk_packages(
+            [str(base_path)], prefix=f"{package_name}.", onerror=lambda e: logger.error("Walk error: %s", e)
+        ):
+            if is_pkg or module_name in results:
+                continue
+            results[module_name] = self._process_module(module_name, base_path, package_name)
+        return results
+
+    def _process_module(self, module_name: str, base_path: Path, package_name: str) -> bool:
+        """Validate module file, import it, and validate the trigger class.
+
+        Args:
+            module_name: Full dotted module path.
+            base_path: Filesystem base path of the package.
+            package_name: Root package for path resolution.
+
+        Returns:
+            True if import and validation succeed, False otherwise.
+        """
+        try:
+            module_file = self._module_file_path(module_name, base_path, package_name)
+            self._validate_module_path(module_file, base_path)
+            if not fnmatch(module_file.name, self.file_pattern):
+                return False
+            if not self._is_safe_module_name(module_name):
+                logger.debug("Skipping unsafe module: %s", module_name)
+                return False
+            if not self._safe_import_module(module_name, module_file):
+                return False
+
+        except SecurityError:
+            logger.exception("Security violation %s", module_name)
+            return False
+        except Exception:
+            logger.exception("Error processing %s", module_name)
+            return False
+        return True
+
+    @staticmethod
+    def _module_file_path(module_name: str, base_path: Path, package_name: str) -> Path:
+        """Compute filesystem Path for a module's .py file.
+
+        Args:
+            module_name: Full module name.
+            base_path: Base directory of the package.
+            package_name: Root package prefix.
+
+        Returns:
+            Path to the module's .py file.
+        """
+        rel = module_name.replace(f"{package_name}.", "").replace(".", "/")
+        return base_path / f"{rel}.py"
+
+    @staticmethod
+    def _validate_package_name(package_name: str) -> None:
+        """Validate that a package name is safe and well-formed.
+
+        Args:
+            package_name: Dotted Python package name.
+
+        Raises:
+            SecurityError: On invalid package names.
+        """
+        if not package_name or not isinstance(package_name, str):
+            msg = "Package name must be a non-empty string"
+            raise SecurityError(msg)
+        if any(part in package_name for part in ("..", "/", "\\", "\x00")):
+            msg = "Invalid package name: %s"
+            raise SecurityError(msg, package_name)
+        if not all(part.isidentifier() for part in package_name.split(".")):
+            msg = "Invalid Python package name: %s"
+            raise SecurityError(msg, package_name)
+
+    def _validate_file_pattern(self) -> None:
+        """Validate that the file glob pattern is safe.
+
+        Raises:
+            SecurityError: On dangerous patterns.
+        """
+        pattern = self.file_pattern
+        if not pattern or not isinstance(pattern, str):
+            msg = "File pattern must be a non-empty string"
+            raise SecurityError(msg)
+        if any(d in pattern for d in ("..", "/", "\\", "\x00", "**/")):
+            msg = "Dangerous pattern detected: %s"
+            raise SecurityError(msg, pattern)
+        if not pattern.endswith(".py"):
+            msg = "Pattern must target Python files (.py)"
+            raise SecurityError(msg)
+
+    def _validate_module_path(self, module_path: Path, base_path: Path) -> None:
+        """Ensure module_path resides under base_path and is within size limits.
+
+        Args:
+            module_path: Path to the module file.
+            base_path: Root directory for the package.
+
+        Raises:
+            SecurityError: On invalid paths or oversize files.
+        """
+        try:
+            resolved_module = module_path.resolve()
+            resolved_base = base_path.resolve()
+            if not str(resolved_module).startswith(str(resolved_base)):
+                msg = "Path traversal attempt: %s"
+                raise SecurityError(msg, module_path)
+            if not resolved_module.exists() or not resolved_module.is_file():
+                msg = "Invalid module path: %s"
+                raise SecurityError(msg, module_path)
+            if resolved_module.stat().st_size > self.max_file_size:
+                msg = "Module file too large: %s"
+                raise SecurityError(msg, module_path)
+        except (OSError, ValueError) as e:
+            msg = "Invalid module path: %s"
+            raise SecurityError(msg, module_path) from e
+
+    def _is_safe_module_name(self, module_name: str) -> bool:
+        """Check module name against forbidden patterns.
+
+        Args:
+            module_name: Full dotted module name.
+
+        Returns:
+            True if safe, False otherwise.
+        """
+        if not module_name or not all(part.isidentifier() for part in module_name.split(".")):
+            return False
+        return not any(p in module_name for p in self.FORBIDDEN_MODULE_PATTERNS)
+
+    def _safe_import_module(self, module_name: str, module_path: Path) -> bool:
+        """Import a module by spec and execute it.
+
+        Args:
+            module_name: Dotted module name.
+            module_path: Filesystem path to .py file.
+
+        Returns:
+            True if imported successfully, False otherwise.
+        """
+        try:
+            if not self._is_safe_module_name(module_name):
+                return False
+            if module_name in sys.modules:
+                logger.debug("Module %s already imported", module_name)
+                return True
+            spec = importlib.util.spec_from_file_location(module_name, module_path)
+            if spec is None or spec.loader is None:
+                logger.error("Could not create valid spec for %s", module_name)
+                return False
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+            logger.debug("Successfully imported %s", module_name)
+        except Exception:
+            sys.modules.pop(module_name, None)
+            logger.exception("Failed to import %s", module_name)
+            return False
+        return True
+
+    def __str__(self) -> str:
+        """Return a string representation of registered trigger handler classes."""
+        return str(self._trigger_handlers_cls)
+
+    def __init__(
+        self,
+        packages: list[str],
+        file_pattern: str = "*_trigger.py",
+        max_file_size: int = 1024 * 1024,  # 1Mb
+    ) -> None:
+        """Initialize the discoverer.
+
+        Args:
+            packages: List of package names to scan.
+            file_pattern: Glob pattern for matching modules.
+            safe_mode: If True, blocks modules with forbidden names.
+            max_file_size: Limit for module file sizes in bytes.
+        """
+        self.packages = packages
+        self.file_pattern = file_pattern
+        self.max_file_size = max_file_size
+
+    def discover_modules(self) -> dict[str, bool]:
+        """Discover and import matching modules across configured packages.
+
+        Raises:
+            DiscoveryError: If initial inputs are invalid.
+
+        Returns:
+            results infos
+        """
+        self._validate_inputs()
+        results: dict[str, bool] = {}
+        for pkg in self.packages:
+            results.update(self._discover_package(pkg))
+        return results
+
+    def register_trigger(self, handler_cls: type[TriggerHandler]) -> type[TriggerHandler]:
+        """Register a trigger handler class for a specific protocol.
+
+        Args:
+            handler_cls: The trigger handler class to register.
+
+        Returns:
+            The registered trigger handler class.
+
+        Raises:
+            ValueError: If a handler for the protocol is already registered.
+        """
+        key = handler_cls.protocol
+        if key not in self._trigger_handlers_cls:
+            self._trigger_handlers_cls[key] = []
+
+        self._trigger_handlers_cls[key].append(handler_cls)
+        return handler_cls
+
+    def init_handlers(self, context: ModuleContext) -> None:
+        """Initialize all registered trigger handler instances.
+
+        This method iterates over all registered trigger handler classes in
+        `_trigger_handlers_cls`, instantiates each handler with the current module
+        context, and stores the instance in `_trigger_handlers`.
+        This allows the module to dispatch incoming protocol requests
+        to the correct handler instance at runtime while keeping a shared context.
+        """
+        for protocol, handlers_cls in self._trigger_handlers_cls.items():
+            self.trigger_handlers[protocol] = tuple(handler_cls(context) for handler_cls in set(handlers_cls))
+
+    def get_trigger(self, protocol: str, input_instance: InputTrigger) -> TriggerHandler:
+        """Retrieve a trigger handler instance based on the provided protocol and input instance type.
+
+        Args:
+            protocol: The protocol name (ignored internally, `input_instance.protocol` is used instead).
+            input_instance: The input trigger instance used to determine the correct handler.
+
+        Returns:
+            TriggerHandler: An instance of the trigger handler matching the input format.
+
+        Raises:
+            ValueError: If no handler is registered for the specified protocol,
+                        or if no handler matches the type of the input instance.
+        """
+        logger.debug("Trigger type invoked: %s", input_instance)
+        protocol = input_instance.protocol
+
+        if (protocols := self.trigger_handlers.get(protocol)) is None:
+            msg = f"No handler for protocol '{protocol}'"
+            raise ValueError(msg)
+
+        try:
+            handler_instance = next(x for x in protocols if isinstance(input_instance, x.input_format))
+        except Exception:
+            msg = f"No handler for input format '{type(input_instance)=}'"
+            raise ValueError(msg)
+        return handler_instance

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.16
+Version: 0.2.17
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-0.2.16 → digitalkin-0.2.17}/src/digitalkin.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ src/digitalkin/grpc_servers/utils/types.py
 src/digitalkin/models/__init__.py
 src/digitalkin/models/module/__init__.py
 src/digitalkin/models/module/module.py
+src/digitalkin/models/module/module_context.py
 src/digitalkin/models/module/module_types.py
 src/digitalkin/models/services/__init__.py
 src/digitalkin/models/services/cost.py
@@ -46,7 +47,7 @@ src/digitalkin/modules/__init__.py
 src/digitalkin/modules/_base_module.py
 src/digitalkin/modules/archetype_module.py
 src/digitalkin/modules/tool_module.py
-src/digitalkin/modules/trigger_module.py
+src/digitalkin/modules/trigger_handler.py
 src/digitalkin/modules/job_manager/base_job_manager.py
 src/digitalkin/modules/job_manager/job_manager_models.py
 src/digitalkin/modules/job_manager/single_job_manager.py
@@ -87,4 +88,5 @@ src/digitalkin/services/storage/storage_strategy.py
 src/digitalkin/utils/__init__.py
 src/digitalkin/utils/arg_parser.py
 src/digitalkin/utils/development_mode_action.py
-src/digitalkin/utils/llm_ready_schema.py
+src/digitalkin/utils/llm_ready_schema.py
+src/digitalkin/utils/package_discover.py

digitalkin-0.2.16/src/digitalkin/models/module/__init__.py

@@ -1,12 +0,0 @@
-"""This module contains the models for the modules."""
-
-from digitalkin.models.module.module import Module, ModuleStatus
-from digitalkin.models.module.module_types import (
-    ConfigSetupModelT,
-    InputModelT,
-    OutputModelT,
-    SecretModelT,
-    SetupModelT,
-)
-
-__all__ = ["ConfigSetupModelT", "InputModelT", "Module", "ModuleStatus", "OutputModelT", "SecretModelT", "SetupModelT"]

digitalkin-0.2.16/src/digitalkin/models/module/module_types.py

@@ -1,11 +0,0 @@
-"""Types for module models."""
-
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-ConfigSetupModelT = TypeVar("ConfigSetupModelT", bound=BaseModel | None)
-InputModelT = TypeVar("InputModelT", bound=BaseModel)
-OutputModelT = TypeVar("OutputModelT", bound=BaseModel)
-SetupModelT = TypeVar("SetupModelT", bound=BaseModel)
-SecretModelT = TypeVar("SecretModelT", bound=BaseModel)

digitalkin-0.2.16/src/digitalkin/modules/trigger_module.py

@@ -1,11 +0,0 @@
-"""TriggerModule extends BaseModule to implement specific module types."""
-
-from abc import ABC
-
-from digitalkin.models.module.module_types import ConfigSetupModelT
-from digitalkin.modules._base_module import BaseModule, InputModelT, OutputModelT, SecretModelT, SetupModelT
-
-
-class TriggerModule(BaseModule[InputModelT, OutputModelT, SetupModelT, SecretModelT,
-        ConfigSetupModelT,], ABC):
-    """TriggerModule extends BaseModule to implement specific module types."""