omnibase_infra 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

omnibase_infra/nodes/node_registration_storage_effect/registry/registry_infra_registration_storage.py

@@ -17,6 +17,12 @@ Related:
     - NodeRegistrationStorageEffect: Effect node that uses these dependencies
     - ProtocolRegistrationPersistence: Protocol for storage backends
     - ModelONEXContainer: ONEX dependency injection container
+
+Note:
+    This registry uses a module-level dict for handler storage because the
+    ServiceRegistry in omnibase_core v1.0 doesn't support dict-style access
+    or string-keyed multi-handler routing. The handlers are still validated
+    against the protocol but stored separately.
 """
 
 from __future__ import annotations
@@ -31,6 +37,12 @@ if TYPE_CHECKING:
 
 __all__ = ["RegistryInfraRegistrationStorage"]
 
+# Module-level storage for handlers and metadata
+# ServiceRegistry in v1.0 doesn't support dict-style access needed for
+# multi-handler routing (e.g., "postgresql", "mock" handler types)
+_HANDLER_STORAGE: dict[str, object] = {}
+_PROTOCOL_METADATA: dict[str, dict[str, object]] = {}
+
 
 class RegistryInfraRegistrationStorage:
     """Registry for registration storage node dependencies.
@@ -72,14 +84,18 @@ class RegistryInfraRegistrationStorage:
     DEFAULT_HANDLER_TYPE = "postgresql"
 
     @staticmethod
-    def register(container: ModelONEXContainer) -> None:
+    def register(_container: ModelONEXContainer) -> None:
         """Register registration storage dependencies with the container.
 
         Registers the protocol key for later handler binding. This method
         sets up the infrastructure but does not bind a specific handler.
 
         Args:
-            container: ONEX dependency injection container.
+            _container: ONEX dependency injection container. Currently unused
+                because ServiceRegistry v1.0 doesn't support dict-style access
+                for multi-handler routing. The parameter is retained for API
+                consistency with other registry methods and future migration
+                when ServiceRegistry supports the required access patterns.
 
         Example:
             >>> from omnibase_core.models.container import ModelONEXContainer
@@ -88,20 +104,19 @@ class RegistryInfraRegistrationStorage:
         """
         # Register protocol metadata for discovery
         # Actual handler binding happens via register_handler()
-        if container.service_registry is not None:
-            container.service_registry[
-                RegistryInfraRegistrationStorage.PROTOCOL_KEY
-            ] = {
-                "protocol": "ProtocolRegistrationPersistence",
-                "module": "omnibase_infra.nodes.node_registration_storage_effect.protocols",
-                "description": "Protocol for registration storage backends",
-                "pluggable": True,
-                "implementations": ["postgresql", "mock"],
-            }
+        # Note: Uses module-level storage since ServiceRegistry v1.0 doesn't
+        # support dict-style access for multi-handler routing
+        _PROTOCOL_METADATA[RegistryInfraRegistrationStorage.PROTOCOL_KEY] = {
+            "protocol": "ProtocolRegistrationPersistence",
+            "module": "omnibase_infra.nodes.node_registration_storage_effect.protocols",
+            "description": "Protocol for registration storage backends",
+            "pluggable": True,
+            "implementations": ["postgresql", "mock"],
+        }
 
     @staticmethod
     def register_handler(
-        container: ModelONEXContainer,
+        _container: ModelONEXContainer,
         handler: ProtocolRegistrationPersistence,
     ) -> None:
         """Register a specific storage handler with the container.
@@ -110,7 +125,11 @@ class RegistryInfraRegistrationStorage:
         The handler must implement ProtocolRegistrationPersistence.
 
         Args:
-            container: ONEX dependency injection container.
+            _container: ONEX dependency injection container. Currently unused
+                because ServiceRegistry v1.0 doesn't support dict-style access
+                for multi-handler routing. The parameter is retained for API
+                consistency and future migration when ServiceRegistry supports
+                the required access patterns.
             handler: Handler implementation to register.
 
         Raises:
@@ -120,7 +139,7 @@ class RegistryInfraRegistrationStorage:
             >>> from omnibase_infra.handlers.registration_storage import (
             ...     HandlerRegistrationStoragePostgres,
             ... )
-            >>> handler = HandlerRegistrationStoragePostgres(pool, config)
+            >>> handler = HandlerRegistrationStoragePostgres(container, dsn="postgresql://...")
             >>> RegistryInfraRegistrationStorage.register_handler(container, handler)
         """
         # Import at runtime for isinstance check (protocol is @runtime_checkable)
@@ -143,32 +162,35 @@ class RegistryInfraRegistrationStorage:
                 f"got {type(handler).__name__}"
             )
 
-        if container.service_registry is None:
-            return
-
+        # Note: Uses module-level storage since ServiceRegistry v1.0 doesn't
+        # support dict-style access for multi-handler routing
         handler_key = (
             f"{RegistryInfraRegistrationStorage.PROTOCOL_KEY}.{handler.handler_type}"
         )
-        container.service_registry[handler_key] = handler
+        _HANDLER_STORAGE[handler_key] = handler
 
         # Also register as default if it matches the default type
         if (
             handler.handler_type
             == RegistryInfraRegistrationStorage.DEFAULT_HANDLER_TYPE
         ):
-            container.service_registry[
+            _HANDLER_STORAGE[
                 RegistryInfraRegistrationStorage.PROTOCOL_KEY + ".default"
             ] = handler
 
     @staticmethod
     def get_handler(
-        container: ModelONEXContainer,
+        _container: ModelONEXContainer,
         handler_type: str | None = None,
     ) -> ProtocolRegistrationPersistence | None:
         """Retrieve a registered storage handler from the container.
 
         Args:
-            container: ONEX dependency injection container.
+            _container: ONEX dependency injection container. Currently unused
+                because ServiceRegistry v1.0 doesn't support dict-style access
+                for multi-handler routing. The parameter is retained for API
+                consistency and future migration when ServiceRegistry supports
+                the required access patterns.
             handler_type: Specific handler type to retrieve. If None, returns default.
 
         Returns:
@@ -180,9 +202,8 @@ class RegistryInfraRegistrationStorage:
             ...     handler_type="postgresql",
             ... )
         """
-        if container.service_registry is None:
-            return None
-
+        # Note: Uses module-level storage since ServiceRegistry v1.0 doesn't
+        # support dict-style access for multi-handler routing
         if handler_type is not None:
             handler_key = (
                 f"{RegistryInfraRegistrationStorage.PROTOCOL_KEY}.{handler_type}"
@@ -190,5 +211,5 @@ class RegistryInfraRegistrationStorage:
         else:
             handler_key = RegistryInfraRegistrationStorage.PROTOCOL_KEY + ".default"
 
-        result = container.service_registry.get(handler_key)
+        result = _HANDLER_STORAGE.get(handler_key)
         return cast("ProtocolRegistrationPersistence | None", result)

omnibase_infra/nodes/node_registry_effect/contract.yaml

@@ -12,11 +12,6 @@
 name: "node_registry_effect"
 contract_name: "node_registry_effect"
 node_name: "node_registry_effect"
-# Version (semantic versioning)
-version:
-  major: 1
-  minor: 1
-  patch: 0
 contract_version:
   major: 1
   minor: 1

omnibase_infra/nodes/node_registry_effect/handlers/handler_partial_retry.py

@@ -41,6 +41,7 @@ import time
 from typing import TYPE_CHECKING, Protocol, runtime_checkable
 from uuid import UUID
 
+from omnibase_core.models.primitives import ModelSemVer
 from omnibase_infra.enums import EnumBackendType
 from omnibase_infra.errors import (
     InfraAuthenticationError,
@@ -80,7 +81,7 @@ class ProtocolPartialRetryRequest(Protocol):
 
     node_id: UUID
     node_type: EnumNodeKind
-    node_version: str
+    node_version: ModelSemVer
     target_backend: EnumBackendType
     idempotency_key: str | None
     service_name: str | None

omnibase_infra/nodes/node_service_discovery_effect/registry/registry_infra_service_discovery.py

@@ -40,6 +40,7 @@ Related:
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING
 
 from omnibase_infra.errors import ProtocolConfigurationError
@@ -50,6 +51,8 @@ if TYPE_CHECKING:
         ProtocolDiscoveryOperations,
     )
 
+logger = logging.getLogger(__name__)
+
 
 class RegistryInfraServiceDiscovery:
     """Registry for service discovery node dependencies.
@@ -59,11 +62,11 @@ class RegistryInfraServiceDiscovery:
     registration and explicit handler configuration.
 
     API Pattern Note:
-        This registry uses ``container.register_factory()`` and
-        ``container.register_instance()`` for protocol-based type-safe DI
-        resolution. This differs from RegistryInfraRegistrationStorage which
-        uses ``container.service_registry[key]`` dict access for multi-handler
-        routing by type string (e.g., "postgresql", "mock").
+        This registry uses ``container.service_registry.register_instance()``
+        for protocol-based type-safe DI resolution. This differs from
+        RegistryInfraRegistrationStorage which uses a module-level dict for
+        multi-handler routing by type string (e.g., "postgresql", "mock"),
+        as ServiceRegistry does not support dict-style indexed access.
 
         The different patterns serve different purposes:
         - Protocol-based registration: Single handler per protocol type
@@ -83,7 +86,10 @@ class RegistryInfraServiceDiscovery:
             RegistryInfraServiceDiscovery.register(container)
 
             # Explicit handler registration
-            consul_handler = HandlerServiceDiscoveryConsul(config)
+            consul_handler = HandlerServiceDiscoveryConsul(
+                container=container,
+                consul_host="localhost",
+            )
             RegistryInfraServiceDiscovery.register_with_handler(
                 container,
                 handler=consul_handler,
@@ -113,21 +119,18 @@ class RegistryInfraServiceDiscovery:
         if container.service_registry is None:
             return
 
-        # Import here to avoid circular imports
-        from omnibase_infra.nodes.node_service_discovery_effect.protocols import (
-            ProtocolDiscoveryOperations,
-        )
-
-        # Register protocol with lazy resolution
-        # The actual implementation is determined at resolution time
-        # based on configuration (CONSUL_AGENT_URL, K8S_NAMESPACE, etc.)
-        container.register_factory(
-            ProtocolDiscoveryOperations,
-            RegistryInfraServiceDiscovery._create_handler_from_config,
+        # NOTE: Factory registration (register_factory) is not implemented in
+        # omnibase_core v1.0. This method provides no-op registration for forward
+        # compatibility. Use register_with_handler() to explicitly provide a
+        # pre-configured handler instance.
+        logger.debug(
+            "Service discovery factory registration skipped - "
+            "factory registration not implemented in v1.0. "
+            "Use register_with_handler() to register an explicit handler instance."
         )
 
     @staticmethod
-    def register_with_handler(
+    async def register_with_handler(
         container: ModelONEXContainer,
         handler: ProtocolDiscoveryOperations,
     ) -> None:
@@ -146,12 +149,13 @@ class RegistryInfraServiceDiscovery:
         Example:
             >>> container = ModelONEXContainer()
             >>> handler = HandlerServiceDiscoveryConsul(config)
-            >>> RegistryInfraServiceDiscovery.register_with_handler(
+            >>> await RegistryInfraServiceDiscovery.register_with_handler(
             ...     container,
             ...     handler=handler,
             ... )
         """
         # Import at runtime for isinstance check (protocol is @runtime_checkable)
+        from omnibase_core.enums import EnumInjectionScope
         from omnibase_infra.nodes.node_service_discovery_effect.protocols import (
             ProtocolDiscoveryOperations,
         )
@@ -174,7 +178,11 @@ class RegistryInfraServiceDiscovery:
         if container.service_registry is None:
             return
 
-        container.register_instance(ProtocolDiscoveryOperations, handler)
+        await container.service_registry.register_instance(
+            interface=ProtocolDiscoveryOperations,  # type: ignore[type-abstract]
+            instance=handler,
+            scope=EnumInjectionScope.GLOBAL,
+        )
 
     @staticmethod
     def _create_handler_from_config(

omnibase_infra/plugins/examples/plugin_json_normalizer.py

@@ -75,12 +75,12 @@ class PluginJsonNormalizer(PluginComputeBase):
             effective_max_depth = self.MAX_RECURSION_DEPTH
 
         try:
-            json_data = cast(object, input_data.get("json", {}))
+            json_data = cast("object", input_data.get("json", {}))
             normalized: object = self._sort_keys_recursively(
                 json_data, _max_depth=effective_max_depth
             )
             output: JsonNormalizerOutput = {"normalized": normalized}
-            return cast(ModelPluginOutputData, output)
+            return cast("ModelPluginOutputData", output)
 
         except RecursionError as e:
             raise OnexError(

omnibase_infra/plugins/examples/plugin_json_normalizer_error_handling.py

@@ -80,14 +80,14 @@ class PluginJsonNormalizerErrorHandling(PluginComputeBase):
 
         try:
             # Retrieve JSON data with safe default
-            json_data = cast(object, input_data.get("json", {}))
+            json_data = cast("object", input_data.get("json", {}))
 
             # Perform pure deterministic computation
             normalized = self._sort_keys_recursively(json_data)
 
             # Return result with correlation_id for tracing
             return cast(
-                ModelPluginOutputData,
+                "ModelPluginOutputData",
                 {
                     "normalized": normalized,
                     "correlation_id": correlation_id,

omnibase_infra/plugins/plugin_compute_base.py

@@ -105,9 +105,15 @@ ONEX 4-Node Architecture Integration:
 
         # Step 2: Integrate with NodeComputeService (I/O wrapper)
         class ValidationNode(NodeComputeService):
-            def __init__(self, container: ONEXContainer):
+            def __init__(self, container: ONEXContainer, plugin: ProtocolPluginCompute):
                 super().__init__(container)
-                self.plugin = container.resolve(ProtocolPluginCompute)
+                # Plugin is injected via constructor (sync-friendly)
+                # Resolution from container happens at initialization time:
+                #   plugin = await container.service_registry.resolve_service(
+                #       ProtocolPluginCompute
+                #   )
+                #   node = ValidationNode(container, plugin)
+                self.plugin = plugin
 
             async def execute(self, input_model: ModelInput) -> ModelOutput:
                 # Node handles I/O and state management
@@ -119,6 +125,14 @@ ONEX 4-Node Architecture Integration:
 
                 # Node handles output persistence (if needed)
                 return ModelOutput(**result)
+
+        # Complete initialization example:
+        async def create_validation_node(container: ONEXContainer) -> ValidationNode:
+            '''Factory function for creating ValidationNode with resolved plugin.'''
+            plugin = await container.service_registry.resolve_service(
+                ProtocolPluginCompute
+            )
+            return ValidationNode(container, plugin)
         ```
 
     When to Use Plugin vs Direct Node Implementation:

omnibase_infra/protocols/__init__.py

@@ -62,6 +62,7 @@ from omnibase_infra.protocols.protocol_capability_projection import (
     ProtocolCapabilityProjection,
 )
 from omnibase_infra.protocols.protocol_capability_query import ProtocolCapabilityQuery
+from omnibase_infra.protocols.protocol_container_aware import ProtocolContainerAware
 from omnibase_infra.protocols.protocol_event_bus_like import ProtocolEventBusLike
 from omnibase_infra.protocols.protocol_event_projector import ProtocolEventProjector
 from omnibase_infra.protocols.protocol_idempotency_store import (
@@ -88,6 +89,7 @@ __all__: list[str] = [
     "ProtocolCapabilityQuery",
     "ProtocolEventBusLike",
     "ProtocolEventProjector",
+    "ProtocolContainerAware",
     "ProtocolIdempotencyStore",
     "ProtocolMessageDispatcher",
     "ProtocolMessageTypeRegistry",

omnibase_infra/protocols/protocol_container_aware.py

@@ -0,0 +1,200 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Protocol extension for Infrastructure Handlers with Container DI.
+
+This module defines the ProtocolContainerAware interface, which extends the base
+ProtocolHandler from omnibase_spi to add container-based dependency injection
+requirements. All infrastructure handlers in omnibase_infra must implement this
+extended protocol.
+
+Why This Protocol Exists:
+    The base ProtocolHandler in omnibase_spi is intentionally minimal and doesn't
+    mandate a specific constructor signature. This keeps the SPI layer decoupled
+    from implementation details.
+
+    However, omnibase_infra handlers require ModelONEXContainer for:
+    - Dependency injection of shared services (connection pools, clients)
+    - Configuration access without global state
+    - Testability through container mocking
+
+    This protocol adds the __init__ signature requirement while inheriting all
+    method requirements from the base protocol.
+
+Protocol Hierarchy:
+    omnibase_spi.ProtocolHandler (base)
+        - handler_type property
+        - initialize()
+        - shutdown()
+        - execute()
+        - describe()
+        - health_check()
+
+    omnibase_infra.ProtocolContainerAware (extension)
+        - All methods from ProtocolHandler
+        - __init__(container: ModelONEXContainer) requirement
+
+Usage:
+    Infrastructure handlers should implement this extended protocol:
+
+    ```python
+    from omnibase_core.container import ModelONEXContainer
+    from omnibase_infra.protocols import ProtocolContainerAware
+
+    class HandlerDatabase:
+        '''Database handler implementing the infra protocol.'''
+
+        def __init__(self, container: ModelONEXContainer) -> None:
+            self._container = container
+            # Access shared resources via container
+
+        @property
+        def handler_type(self) -> str:
+            return "db"
+
+        # ... implement remaining protocol methods ...
+    ```
+
+    The RuntimeHostProcess uses this protocol for type-safe handler instantiation:
+
+    ```python
+    handler_cls: type[ProtocolContainerAware] = handler_registry.get(handler_type)
+    handler_instance = handler_cls(container=container)  # Type-safe
+    ```
+
+Thread Safety:
+    Handler implementations must be thread-safe. The container provides access
+    to shared resources that may be used concurrently.
+
+See Also:
+    - omnibase_spi.protocols.handlers.protocol_handler.ProtocolHandler
+    - omnibase_core.container.ModelONEXContainer
+    - CLAUDE.md section "Container-Based Dependency Injection"
+    - PR #186: Container DI refactoring for handlers
+
+.. versionadded:: 0.7.1
+    Created as part of OMN-1434 container DI standardization.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+from omnibase_spi.protocols.handlers.protocol_handler import (
+    ProtocolHandler as ProtocolHandlerBase,
+)
+
+if TYPE_CHECKING:
+    from omnibase_core.container import ModelONEXContainer
+
+__all__ = [
+    "ProtocolContainerAware",
+]
+
+
+@runtime_checkable
+class ProtocolContainerAware(ProtocolHandlerBase, Protocol):
+    """Extended protocol for infrastructure handlers with container DI.
+
+    This protocol extends the base ProtocolHandler from omnibase_spi to require
+    a constructor that accepts ModelONEXContainer for dependency injection.
+
+    All infrastructure handlers in omnibase_infra must implement this protocol.
+    The container provides access to:
+    - Database connection pools
+    - HTTP clients
+    - Service discovery clients
+    - Configuration values
+    - Logging context
+
+    Methods inherited from ProtocolHandler:
+        handler_type: Property returning the handler type identifier.
+        initialize: Initialize clients and connection pools.
+        shutdown: Release resources and close connections.
+        execute: Execute protocol-specific operations.
+        describe: Return handler metadata and capabilities.
+        health_check: Check handler health and connectivity.
+
+    Constructor Requirement (added by this protocol):
+        __init__: Must accept container: ModelONEXContainer as first positional argument.
+
+    Example:
+        ```python
+        from omnibase_core.container import ModelONEXContainer
+
+        class HandlerConsul:
+            def __init__(self, container: ModelONEXContainer) -> None:
+                self._container = container
+                self._consul_url = container.config.get("consul_url")
+
+            @property
+            def handler_type(self) -> str:
+                return "consul"
+
+            async def initialize(self, config):
+                # Use container for shared resources
+                ...
+
+            # ... implement remaining methods ...
+        ```
+
+    Protocol Verification:
+        Per ONEX conventions, verify protocol compliance via duck typing:
+
+        ```python
+        handler_cls = handler_registry.get("http")
+
+        # Verify constructor signature accepts container
+        import inspect
+        sig = inspect.signature(handler_cls.__init__)
+        params = list(sig.parameters.keys())
+        assert "container" in params or len(params) > 1  # self + container
+
+        # Verify protocol methods exist
+        assert hasattr(handler_cls, "handler_type")
+        assert hasattr(handler_cls, "initialize") and callable(getattr(handler_cls, "initialize"))
+        ```
+
+    Note:
+        Method bodies in this Protocol use ``...`` (Ellipsis) rather than
+        ``raise NotImplementedError()``. This is the standard Python convention
+        for ``typing.Protocol`` classes per PEP 544.
+    """
+
+    def __init__(self, container: ModelONEXContainer) -> None:
+        """Initialize the handler with a dependency injection container.
+
+        All infrastructure handlers receive their dependencies through the
+        container rather than as individual constructor arguments. This enables:
+
+        - Consistent initialization across all handlers
+        - Easy testing through container mocking
+        - Runtime configuration without code changes
+        - Shared resource management (connection pools, clients)
+
+        Args:
+            container: ONEX dependency injection container providing access to:
+                - Configuration values (container.config)
+                - Shared services (database pools, HTTP clients)
+                - Logging context
+                - Runtime metadata
+
+        Note:
+            Handlers should store the container reference and access dependencies
+            lazily when needed, rather than extracting all values in __init__.
+            This improves startup time and allows for late-bound configuration.
+
+        Example:
+            ```python
+            def __init__(self, container: ModelONEXContainer) -> None:
+                self._container = container
+                self._client: httpx.AsyncClient | None = None  # Lazy init
+
+            async def initialize(self, config):
+                # Create client during initialize(), not __init__()
+                self._client = httpx.AsyncClient(
+                    base_url=self._container.config.get("base_url"),
+                    timeout=config.get("timeout", 30.0),
+                )
+            ```
+        """
+        ...

omnibase_infra/protocols/protocol_event_projector.py

@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING, Protocol, runtime_checkable
 from uuid import UUID
 
 if TYPE_CHECKING:
-    from omnibase_core.models.events import ModelEventEnvelope
+    from omnibase_core.models.events.model_event_envelope import ModelEventEnvelope
     from omnibase_core.models.projectors import ModelProjectionResult