digitalkin 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

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.18"

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/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/models/module/__init__.py

@@ -1,12 +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", "InputModelT", "Module", "ModuleStatus", "OutputModelT", "SecretModelT", "SetupModelT"]
+__all__ = [
+    "ConfigSetupModelT",
+    "InputModel",
+    "InputModelT",
+    "InputTrigger",
+    "Module",
+    "ModuleContext",
+    "ModuleStatus",
+    "OutputModelT",
+    "SecretModelT",
+    "SetupModelT",
+]

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/models/module/module_types.py

@@ -4,8 +4,40 @@ 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=BaseModel)
+InputModelT = TypeVar("InputModelT", bound=InputModel)
 OutputModelT = TypeVar("OutputModelT", bound=BaseModel)
 SetupModelT = TypeVar("SetupModelT", bound=BaseModel)
 SecretModelT = TypeVar("SecretModelT", bound=BaseModel)

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/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/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/services/filesystem/default_filesystem.py

@@ -126,7 +126,7 @@ class DefaultFilesystem(FilesystemStrategy):
                     raise FilesystemServiceError(msg)  # noqa: TRY301
 
                 Path(file_path).write_bytes(file.content)
-                storage_url = str(Path(file_path).resolve())
+                storage_uri = str(Path(file_path).resolve())
                 file_data = FilesystemRecord(
                     id=str(uuid.uuid4()),
                     context=self.mission_id,
@@ -136,7 +136,8 @@ class DefaultFilesystem(FilesystemStrategy):
                     size_bytes=len(file.content),
                     checksum=self._calculate_checksum(file.content),
                     metadata=file.metadata,
-                    storage_url=storage_url,
+                    storage_uri=storage_uri,
+                    file_url=storage_uri,
                     status=file.status if hasattr(file, "status") and file.status else "ACTIVE",
                 )
 
@@ -200,7 +201,7 @@ class DefaultFilesystem(FilesystemStrategy):
 
             if include_content:
                 for file in paginated_files:
-                    file.content = Path(file.storage_url).read_bytes()
+                    file.content = Path(file.storage_uri).read_bytes()
 
         except Exception as e:
             msg = f"Error listing files: {e!s}"
@@ -243,7 +244,7 @@ class DefaultFilesystem(FilesystemStrategy):
                 raise FilesystemServiceError(msg)  # noqa: TRY301
 
             if include_content:
-                file_path = file_data.storage_url
+                file_path = file_data.storage_uri
                 if os.path.exists(file_path):
                     content = Path(file_path).read_bytes()
                     file_data.content = content
@@ -330,7 +331,7 @@ class DefaultFilesystem(FilesystemStrategy):
                 new_path = os.path.join(context_dir, new_name)
                 os.rename(file_path, new_path)
                 existing_file.name = new_name
-                existing_file.storage_url = str(Path(new_path).resolve())
+                existing_file.storage_uri = str(Path(new_path).resolve())
 
             self.db[file_id] = existing_file
 
@@ -388,7 +389,7 @@ class DefaultFilesystem(FilesystemStrategy):
                     continue
 
                 try:
-                    file_path = file_data.storage_url
+                    file_path = file_data.storage_uri
                     if os.path.exists(file_path):
                         if permanent:
                             os.remove(file_path)

digitalkin/services/filesystem/filesystem_strategy.py

@@ -24,7 +24,8 @@ class FilesystemRecord(BaseModel):
     size_bytes: int = Field(default=0, description="Size of the file in bytes")
     checksum: str = Field(default="", description="SHA-256 checksum of the file content")
     metadata: dict[str, Any] | None = Field(default=None, description="Additional metadata for the file")
-    storage_url: str = Field(description="Internal URL for accessing the file content")
+    storage_uri: str = Field(description="Internal URI for accessing the file content")
+    file_url: str = Field(description="Public URL for accessing the file content")
     status: str = Field(default="UNSPECIFIED", description="Current status of the file")
     content: bytes | None = Field(default=None, description="The content of the file")
 

digitalkin/services/filesystem/grpc_filesystem.py

@@ -121,7 +121,8 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             size_bytes=file.size_bytes,
             checksum=file.checksum,
             metadata=MessageToDict(file.metadata),
-            storage_url=file.storage_url,
+            storage_uri=file.storage_uri,
+            file_url=file.file_url,
             status=filesystem_pb2.FileStatus.Name(file.status),
             content=file.content,
         )

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.dist-info → digitalkin-0.2.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.16
+Version: 0.2.18
 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.15
+Requires-Dist: digitalkin-proto>=0.1.16
 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.16.dist-info → digitalkin-0.2.18.dist-info}/RECORD

@@ -7,13 +7,13 @@ base_server/mock/__init__.py,sha256=YZFT-F1l_TpvJYuIPX-7kTeE1CfOjhx9YmNRXVoi-jQ,
 base_server/mock/mock_pb2.py,sha256=sETakcS3PAAm4E-hTCV1jIVaQTPEAIoVVHupB8Z_k7Y,1843
 base_server/mock/mock_pb2_grpc.py,sha256=BbOT70H6q3laKgkHfOx1QdfmCS_HxCY4wCOX84YAdG4,3180
 digitalkin/__init__.py,sha256=7LLBAba0th-3SGqcpqFO-lopWdUkVLKzLZiMtB-mW3M,162
-digitalkin/__version__.py,sha256=M-XK8XT3lEHqZRrh1JSvDJX8Ri-RXYjKzp3zOM-qaDA,191
+digitalkin/__version__.py,sha256=Xmsz_szPPAmeYnVobFHJO8pKINhzpB446tyRoVs8I2Y,191
 digitalkin/logger.py,sha256=cFbIAZHOFx3nddOssRNYLXyqUPzR4CgDR_c-5wmB-og,1685
 digitalkin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 digitalkin/grpc_servers/__init__.py,sha256=0cJBlwipSmFdXkyH3T0i6OJ1WpAtNsZgYX7JaSnkbtg,804
 digitalkin/grpc_servers/_base_server.py,sha256=NXnnZPjJqUDWoumhEbb7EOEWB7d8XYwpQs-l97NTe4k,18647
-digitalkin/grpc_servers/module_server.py,sha256=tc4n8fu7bcMkwCI3CKkAKR4cZqyP_JTEW0lGtqsc5hs,10283
-digitalkin/grpc_servers/module_servicer.py,sha256=DZ1c_3XAXt-m5I6-CGqmrQ8TAFrYCUQj8R5rqMDKeQc,18383
+digitalkin/grpc_servers/module_server.py,sha256=hOvoY2XFjxmgkbAsMex5a-m7OPyljnz0Gh9BJxtDtJo,10259
+digitalkin/grpc_servers/module_servicer.py,sha256=yHlzMBBdjdEirx6otG0u3fNy-nZgFkK2HAWQJ6LA7jQ,18415
 digitalkin/grpc_servers/registry_server.py,sha256=StY18DKYoPKQIU1SIzgito6D4_QA1aMVddZ8O2WGlHY,2223
 digitalkin/grpc_servers/registry_servicer.py,sha256=dqsKGHZ0LnaIvGt4ipaAuigd37sbJBndT4MAT029GsY,16471
 digitalkin/grpc_servers/utils/exceptions.py,sha256=SyOgvjggaUECYmSiqy8KJLHwHVt5IClSTxslHM-IZzI,931
@@ -22,17 +22,18 @@ digitalkin/grpc_servers/utils/grpc_client_wrapper.py,sha256=GXRqCTCufwWd8sVMoCln
 digitalkin/grpc_servers/utils/models.py,sha256=80F5oHiv8MOqMoDZJBXmJSRoVYJRyhaVcijQ2LinAig,8428
 digitalkin/grpc_servers/utils/types.py,sha256=rQ78s4nAet2jy-NIDj_PUWriT0kuGHr_w6ELjmjgBao,539
 digitalkin/models/__init__.py,sha256=hDHtUfswaNh8wo4NZaBItg9JqC0uNSRqXArNWSrGynY,163
-digitalkin/models/module/__init__.py,sha256=iQJgq3OVvxoY6gkNCVdVz5bSGgLCy0TMY5H1FFxs-0Q,389
+digitalkin/models/module/__init__.py,sha256=CSnXBcuE8omdbQllfPQGMHaWsfiN7FJyigEv1eZeO4M,579
 digitalkin/models/module/module.py,sha256=NWOwCeD_NH0NL89AF_NJ0SwE7G1n-HTcRalodLCDmpM,749
-digitalkin/models/module/module_types.py,sha256=rlT6prjBN-h1sLKstSwjxWXiyFgtxEn1mjOSLgfI6uA,385
+digitalkin/models/module/module_context.py,sha256=AL6bzwjYfYPLHb1Hu5kKBjaIOxCpBCPMvxEnapdyrX4,1003
+digitalkin/models/module/module_types.py,sha256=HWp-CRG0AB7ve9CRqOegbcwqDgXZ0hmS-QxDpgbdMmI,1196
 digitalkin/models/services/__init__.py,sha256=HsW7MUGFPvH7Ri28WN4BHHBfEQk5dzU_9FOWAc-0lSE,56
 digitalkin/models/services/cost.py,sha256=QTEuFD6xz62nob0z4ksE-INJWcZ-iFiuNW5mvXhpFes,1599
 digitalkin/models/services/storage.py,sha256=cYTVIriGKiprF9OerhSxmc_jM6fUTVwmeon1yQCinkE,143
-digitalkin/modules/__init__.py,sha256=ppYARmhvdVi55ofC0QZerIempSlcJYDeCXhcl4qXObw,278
-digitalkin/modules/_base_module.py,sha256=wFnGGN97RNu3TJMdgMktOKdYPWmJL9WnwR120bPRXQg,12922
+digitalkin/modules/__init__.py,sha256=VwVbKok81NGyPIBZgEj_SR-59G8tTlSb4eBJI9W6Vx4,281
+digitalkin/modules/_base_module.py,sha256=tYFWMB09jO0VLOYA3pUSHeI7ujdwnsIqmgPDJE2WtSU,15981
 digitalkin/modules/archetype_module.py,sha256=7rleVOkZfFR7TQeaq6oZXLBuRWixKsUJMOr9HfDV0T8,566
 digitalkin/modules/tool_module.py,sha256=7eWem70dEJiyoCtkGIJP4Ak2G8MzSruOjrByQMqW9-I,508
-digitalkin/modules/trigger_module.py,sha256=FNiJmG3nTG1nDqKC1XdJI8PmFNZNPs1_QrH6RX7ev2Y,475
+digitalkin/modules/trigger_handler.py,sha256=TpxFc_xkYia9B9rAvHkj02e818W08JOfIqssQqbsCpM,1785
 digitalkin/modules/job_manager/base_job_manager.py,sha256=Ku_MT7Cuf1R_qJU7SV-yHkzUhhMtmDOa8t5DyetvMxw,6177
 digitalkin/modules/job_manager/job_manager_models.py,sha256=onHy-DfInLZQveniMIWIKwTKSQjojz500JvHB54x93c,1129
 digitalkin/modules/job_manager/single_job_manager.py,sha256=DkQV3-E9XqgmuC6hoYKolTX2iv9lUJ8BSCde3zk1OU8,10264
@@ -50,9 +51,9 @@ digitalkin/services/cost/cost_strategy.py,sha256=VhHeqi9WnE1yoDBBVp5qmqwIt5tTZHU
 digitalkin/services/cost/default_cost.py,sha256=mEd0VL_tMcGU41q0f9MFeBYeKZBenv0mIHuwgXlQ7uQ,3869
 digitalkin/services/cost/grpc_cost.py,sha256=p_5mG72N7e4bxwBOD9DNokvLtinBILiqCfllmkqpmhw,6253
 digitalkin/services/filesystem/__init__.py,sha256=BhwMl_BUvM0d65fmglkp0SVwn3RfYiUOKJgIMnOCaGM,381
-digitalkin/services/filesystem/default_filesystem.py,sha256=kyNoxnzIAQ-hrBgushwV6GUqtcpno77wUI3qaP7Ge1c,14981
-digitalkin/services/filesystem/filesystem_strategy.py,sha256=-0oad7P0wqL47DJY30snlnGh7RrruFTZT-G9iFmbAk4,9047
-digitalkin/services/filesystem/grpc_filesystem.py,sha256=0U9n4CjTkzscwvFLKYdA0StyHRuV9lCjGbwr7OFrRxI,12453
+digitalkin/services/filesystem/default_filesystem.py,sha256=pQI7Sc9WNJrxxwd21iIviWcrKKuxuj3BdoAT-rghYGk,15023
+digitalkin/services/filesystem/filesystem_strategy.py,sha256=MlSgEDjjCy1GjtpdO_rKiF2NtfP4DpSU_VF2UtwQ7Ug,9130
+digitalkin/services/filesystem/grpc_filesystem.py,sha256=W-TYe76Zbf2KS0Z4NMVUjRdP6m2IzU7-VXiBdecOjpk,12489
 digitalkin/services/identity/__init__.py,sha256=InkeyLgFYYwItx8mePA8HpfacOMWZwwuc0G4pWtKq9s,270
 digitalkin/services/identity/default_identity.py,sha256=Y2auZHrGSZTIN5D8HyjLvLcNbYFM1CNUE23x7p5VIGw,386
 digitalkin/services/identity/identity_strategy.py,sha256=skappBbds1_qa0Gr24FGrNX1N0_OYhYT1Lh7dUaAirE,429
@@ -74,14 +75,15 @@ digitalkin/utils/__init__.py,sha256=sJnY-ZUgsjMfojAjONC1VN14mhgIDnzyOlGkw21rRnM,
 digitalkin/utils/arg_parser.py,sha256=nvjI1pKDY1HfS0oGcMQPtdTQcggXLtpxXMbnMxNEKRU,3109
 digitalkin/utils/development_mode_action.py,sha256=TqRuAF_A7bDD4twRB4PnZcRoNeaiAnEdxM5kvy4aoaA,1511
 digitalkin/utils/llm_ready_schema.py,sha256=JjMug_lrQllqFoanaC091VgOqwAd-_YzcpqFlS7p778,2375
-digitalkin-0.2.16.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
+digitalkin/utils/package_discover.py,sha256=aASTSloPVTp6MAaj5T7ToIeC6NHKajPDjWa1LoGjj3g,13473
+digitalkin-0.2.18.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
 modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modules/cpu_intensive_module.py,sha256=ejB9XPnFfA0uCuFUQbM3fy5UYfqqAlF36rv_P5Ri8ho,8363
 modules/minimal_llm_module.py,sha256=Ijld__ZnhzfLwpXD1XVkLZ7jyKZKyOFZczOpiPttJZc,11216
 modules/text_transform_module.py,sha256=bwPSnEUthZQyfLwcTLo52iAxItAoknkLh8Y3m5aywaY,7251
 services/filesystem_module.py,sha256=71Mcja8jCQqiqFHPdsIXplFIHTvgkxRhp0TRXuCfgkk,7430
 services/storage_module.py,sha256=ybTMqmvGaTrR8PqJ4FU0cwxaDjT36TskVrGoetTGmno,6955
-digitalkin-0.2.16.dist-info/METADATA,sha256=6KBLCX9EMfGWt8ZpkbRDrs9CFD5FtKoAmPa_zwX4fNU,30580
-digitalkin-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-digitalkin-0.2.16.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
-digitalkin-0.2.16.dist-info/RECORD,,
+digitalkin-0.2.18.dist-info/METADATA,sha256=C29QQiRskIqGJUn4NjC_237SGkhAC1j0wEYUdaLzXEY,30580
+digitalkin-0.2.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+digitalkin-0.2.18.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
+digitalkin-0.2.18.dist-info/RECORD,,

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."""