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

omnibase_infra/runtime/handler_contract_source.py

@@ -31,40 +31,29 @@ from __future__ import annotations
 import logging
 import time
 from pathlib import Path
+from typing import cast
 
 import yaml
 from pydantic import ValidationError
 
 from omnibase_core.models.contracts.model_handler_contract import ModelHandlerContract
 from omnibase_core.models.errors.model_onex_error import ModelOnexError
+from omnibase_core.models.primitives import ModelSemVer
 from omnibase_infra.enums import EnumHandlerErrorType, EnumHandlerSourceType
 from omnibase_infra.models.errors import ModelHandlerValidationError
 from omnibase_infra.models.handlers import (
+    LiteralHandlerKind,
     ModelContractDiscoveryResult,
     ModelHandlerDescriptor,
     ModelHandlerIdentifier,
 )
 from omnibase_infra.runtime.protocol_contract_source import ProtocolContractSource
 
-# Rebuild ModelContractDiscoveryResult to resolve the forward reference
-# to ModelHandlerValidationError. This must happen after ModelHandlerValidationError
-# is imported to make the type available for Pydantic validation.
-#
-# Why this pattern is used:
-#   ModelContractDiscoveryResult has a field typed as list[ModelHandlerValidationError].
-#   ModelHandlerValidationError imports ModelHandlerIdentifier from models.handlers.
-#   If ModelContractDiscoveryResult directly imported ModelHandlerValidationError,
-#   it would cause a circular import because models.handlers.__init__.py imports
-#   ModelContractDiscoveryResult.
-#
-# The solution:
-#   1. ModelContractDiscoveryResult uses TYPE_CHECKING to defer the import
-#   2. With PEP 563 (from __future__ import annotations), the annotation becomes
-#      a string at runtime, avoiding the circular import
-#   3. model_rebuild() resolves the string annotation to the actual type after
-#      both classes are defined
-#
-# This is tested in: tests/unit/runtime/test_handler_contract_source.py
+# Forward Reference Resolution:
+# ModelContractDiscoveryResult uses a forward reference to ModelHandlerValidationError.
+# Since we import ModelHandlerValidationError above, we can call model_rebuild() here
+# to resolve the forward reference. This call is idempotent - multiple calls are harmless.
+# This ensures the model is fully defined before we create instances in discover_handlers().
 ModelContractDiscoveryResult.model_rebuild()
 
 logger = logging.getLogger(__name__)
@@ -72,10 +61,212 @@ logger = logging.getLogger(__name__)
 # File pattern for handler contracts
 HANDLER_CONTRACT_FILENAME = "handler_contract.yaml"
 
+
 # Maximum contract file size (10MB) to prevent memory exhaustion
 MAX_CONTRACT_SIZE = 10 * 1024 * 1024
 
 
+# =============================================================================
+# Module-Level Helper Functions
+# =============================================================================
+#
+# These functions are extracted from HandlerContractSource to reduce method count
+# while maintaining the same functionality. They are pure functions that operate
+# on their inputs without requiring instance state.
+# =============================================================================
+
+
+def _sanitize_path_for_logging(path: Path) -> str:
+    """Sanitize a file path for safe inclusion in logs and error messages.
+
+    In production environments, full paths may leak sensitive information
+    about directory structure. This function returns only the filename and
+    parent directory to provide context without exposing full paths.
+
+    Args:
+        path: The full path to sanitize.
+
+    Returns:
+        Sanitized path string showing only parent/filename.
+        For example: "/home/user/code/handlers/handler_contract.yaml"
+        becomes "handlers/handler_contract.yaml".
+    """
+    # Return parent directory name + filename for context
+    # This provides enough info for debugging without full path exposure
+    try:
+        return str(Path(path.parent.name) / path.name)
+    except (ValueError, AttributeError):
+        # Fallback to just filename if parent extraction fails
+        return path.name
+
+
+def _create_parse_error(
+    contract_path: Path,
+    error: yaml.YAMLError,
+) -> ModelHandlerValidationError:
+    """Create a validation error for YAML parse failures.
+
+    Args:
+        contract_path: Path to the failing contract file.
+        error: The YAML parsing error.
+
+    Returns:
+        ModelHandlerValidationError with parse error details.
+    """
+    handler_identity = ModelHandlerIdentifier.from_handler_id(
+        f"unknown@{contract_path.name}"
+    )
+
+    return ModelHandlerValidationError(
+        error_type=EnumHandlerErrorType.CONTRACT_PARSE_ERROR,
+        rule_id="CONTRACT-001",
+        handler_identity=handler_identity,
+        source_type=EnumHandlerSourceType.CONTRACT,
+        message=f"Failed to parse YAML in {_sanitize_path_for_logging(contract_path)}: {error}",
+        remediation_hint="Check YAML syntax and ensure proper indentation",
+        file_path=str(contract_path),
+    )
+
+
+def _create_validation_error(
+    contract_path: Path,
+    error: ValidationError,
+) -> ModelHandlerValidationError:
+    """Create a validation error for contract validation failures.
+
+    Args:
+        contract_path: Path to the failing contract file.
+        error: The Pydantic validation error.
+
+    Returns:
+        ModelHandlerValidationError with validation details.
+    """
+    handler_identity = ModelHandlerIdentifier.from_handler_id(
+        f"unknown@{contract_path.name}"
+    )
+
+    # Extract first error detail for remediation hint
+    error_details = error.errors()
+    if error_details:
+        first_error = error_details[0]
+        field_loc = " -> ".join(str(x) for x in first_error.get("loc", ()))
+        error_msg = str(first_error.get("msg", "validation failed"))
+    else:
+        field_loc = "unknown"
+        error_msg = "validation failed"
+
+    return ModelHandlerValidationError(
+        error_type=EnumHandlerErrorType.CONTRACT_VALIDATION_ERROR,
+        rule_id="CONTRACT-002",
+        handler_identity=handler_identity,
+        source_type=EnumHandlerSourceType.CONTRACT,
+        message=f"Contract validation failed in {_sanitize_path_for_logging(contract_path)}: {error_msg} at {field_loc}",
+        remediation_hint=f"Check the '{field_loc}' field in the contract",
+        file_path=str(contract_path),
+    )
+
+
+def _create_size_limit_error(
+    contract_path: Path,
+    file_size: int,
+) -> ModelHandlerValidationError:
+    """Create a validation error for file size limit violations.
+
+    Args:
+        contract_path: Path to the oversized contract file.
+        file_size: The actual file size in bytes.
+
+    Returns:
+        ModelHandlerValidationError with size limit details.
+    """
+    handler_identity = ModelHandlerIdentifier.from_handler_id(
+        f"unknown@{contract_path.name}"
+    )
+
+    return ModelHandlerValidationError(
+        error_type=EnumHandlerErrorType.CONTRACT_VALIDATION_ERROR,
+        rule_id="CONTRACT-003",
+        handler_identity=handler_identity,
+        source_type=EnumHandlerSourceType.CONTRACT,
+        message=(
+            f"Contract file {_sanitize_path_for_logging(contract_path)} exceeds size limit: "
+            f"{file_size} bytes (max: {MAX_CONTRACT_SIZE} bytes)"
+        ),
+        remediation_hint=(
+            f"Reduce contract file size to under {MAX_CONTRACT_SIZE // (1024 * 1024)}MB. "
+            "Consider splitting into multiple contracts if needed."
+        ),
+        file_path=str(contract_path),
+    )
+
+
+def _create_io_error(
+    contract_path: Path,
+    error: OSError,
+) -> ModelHandlerValidationError:
+    """Create a validation error for I/O failures.
+
+    Args:
+        contract_path: Path to the contract file that failed to read.
+        error: The I/O error encountered.
+
+    Returns:
+        ModelHandlerValidationError with I/O error details.
+    """
+    handler_identity = ModelHandlerIdentifier.from_handler_id(
+        f"unknown@{contract_path.name}"
+    )
+
+    # OSError.strerror may be None for some error types (e.g., custom subclasses),
+    # so use str(error) as a fallback to ensure we always have an error message
+    error_message = error.strerror or str(error)
+
+    return ModelHandlerValidationError(
+        error_type=EnumHandlerErrorType.CONTRACT_PARSE_ERROR,
+        rule_id="CONTRACT-004",
+        handler_identity=handler_identity,
+        source_type=EnumHandlerSourceType.CONTRACT,
+        message=f"Failed to read contract file: {error_message}",
+        remediation_hint="Check file permissions and ensure the file exists",
+        file_path=str(contract_path),
+    )
+
+
+def _create_version_parse_error(
+    contract_path: Path,
+    error_message: str,
+) -> ModelHandlerValidationError:
+    """Create a validation error for version string parse failures.
+
+    Args:
+        contract_path: Path to the contract file with invalid version.
+        error_message: The error message describing the version parse failure.
+
+    Returns:
+        ModelHandlerValidationError with version parse error details.
+    """
+    handler_identity = ModelHandlerIdentifier.from_handler_id(
+        f"unknown@{contract_path.name}"
+    )
+
+    return ModelHandlerValidationError(
+        error_type=EnumHandlerErrorType.CONTRACT_VALIDATION_ERROR,
+        rule_id="CONTRACT-005",
+        handler_identity=handler_identity,
+        source_type=EnumHandlerSourceType.CONTRACT,
+        message=(
+            f"Invalid version string in contract "
+            f"{_sanitize_path_for_logging(contract_path)}: {error_message}"
+        ),
+        remediation_hint=(
+            "Ensure the 'version' field uses semantic versioning format "
+            "(e.g., '1.0.0', '2.1.3-beta.1'). "
+            "Version components must be non-negative integers."
+        ),
+        file_path=str(contract_path),
+    )
+
+
 # =============================================================================
 # HandlerContractSource Implementation
 # =============================================================================
@@ -165,29 +356,6 @@ class HandlerContractSource(ProtocolContractSource):
         """
         return "CONTRACT"
 
-    def _sanitize_path_for_logging(self, path: Path) -> str:
-        """Sanitize a file path for safe inclusion in logs and error messages.
-
-        In production environments, full paths may leak sensitive information
-        about directory structure. This method returns only the filename and
-        parent directory to provide context without exposing full paths.
-
-        Args:
-            path: The full path to sanitize.
-
-        Returns:
-            Sanitized path string showing only parent/filename.
-            For example: "/home/user/code/handlers/handler_contract.yaml"
-            becomes "handlers/handler_contract.yaml".
-        """
-        # Return parent directory name + filename for context
-        # This provides enough info for debugging without full path exposure
-        try:
-            return str(Path(path.parent.name) / path.name)
-        except (ValueError, AttributeError):
-            # Fallback to just filename if parent extraction fails
-            return path.name
-
     async def discover_handlers(
         self,
     ) -> ModelContractDiscoveryResult:
@@ -307,7 +475,7 @@ class HandlerContractSource(ProtocolContractSource):
                         },
                     )
                 except yaml.YAMLError as e:
-                    error = self._create_parse_error(contract_file, e)
+                    error = _create_parse_error(contract_file, e)
                     if not self._graceful_mode:
                         raise ModelOnexError(
                             f"Failed to parse YAML contract at {contract_file}: {e}",
@@ -315,7 +483,7 @@ class HandlerContractSource(ProtocolContractSource):
                         ) from e
                     logger.warning(
                         "Failed to parse YAML contract in %s, continuing in graceful mode",
-                        self._sanitize_path_for_logging(contract_file),
+                        _sanitize_path_for_logging(contract_file),
                         extra={
                             "contract_file": str(contract_file),
                             "error_type": "yaml_parse_error",
@@ -325,7 +493,7 @@ class HandlerContractSource(ProtocolContractSource):
                     )
                     validation_errors.append(error)
                 except ValidationError as e:
-                    error = self._create_validation_error(contract_file, e)
+                    error = _create_validation_error(contract_file, e)
                     if not self._graceful_mode:
                         raise ModelOnexError(
                             f"Contract validation failed at {contract_file}: {e}",
@@ -333,7 +501,7 @@ class HandlerContractSource(ProtocolContractSource):
                         ) from e
                     logger.warning(
                         "Contract validation failed in %s, continuing in graceful mode",
-                        self._sanitize_path_for_logging(contract_file),
+                        _sanitize_path_for_logging(contract_file),
                         extra={
                             "contract_file": str(contract_file),
                             "error_type": "validation_error",
@@ -348,7 +516,9 @@ class HandlerContractSource(ProtocolContractSource):
                     if not self._graceful_mode:
                         raise
 
-                    # Only handle file size limit errors (HANDLER_SOURCE_005) gracefully
+                    # Handle specific error codes gracefully:
+                    # - HANDLER_SOURCE_005: File size limit exceeded
+                    # - HANDLER_SOURCE_007: Invalid version string
                     # Other ModelOnexError types should be re-raised as they may indicate
                     # more serious issues (e.g., configuration errors, programming errors)
                     # Defensive check: error_code should always exist on ModelOnexError,
@@ -362,13 +532,13 @@ class HandlerContractSource(ProtocolContractSource):
                             file_size = contract_file.stat().st_size
                         except OSError:
                             file_size = 0  # File may have been deleted/changed
-                        error = self._create_size_limit_error(
+                        error = _create_size_limit_error(
                             contract_file,
                             file_size,
                         )
                         logger.warning(
                             "Contract file %s exceeds size limit, continuing in graceful mode",
-                            self._sanitize_path_for_logging(contract_file),
+                            _sanitize_path_for_logging(contract_file),
                             extra={
                                 "contract_file": str(contract_file),
                                 "error_type": "size_limit_error",
@@ -378,6 +548,26 @@ class HandlerContractSource(ProtocolContractSource):
                             },
                         )
                         validation_errors.append(error)
+                    elif error_code == "HANDLER_SOURCE_007":
+                        # Invalid version string - extract version from error message
+                        error = _create_version_parse_error(
+                            contract_file,
+                            str(e),
+                        )
+                        logger.warning(
+                            "Contract file %s has invalid version string, "
+                            "continuing in graceful mode",
+                            _sanitize_path_for_logging(contract_file),
+                            extra={
+                                "contract_file": str(contract_file),
+                                "error_type": "version_parse_error",
+                                "error_code": error_code,
+                                "error_message": str(e),
+                                "graceful_mode": self._graceful_mode,
+                                "paths_scanned": len(self._contract_paths),
+                            },
+                        )
+                        validation_errors.append(error)
                     else:
                         # Re-raise unexpected ModelOnexError types even in graceful mode
                         # These may indicate configuration or programming errors
@@ -389,10 +579,10 @@ class HandlerContractSource(ProtocolContractSource):
                             f"Failed to read contract file at {contract_file}: {e}",
                             error_code="HANDLER_SOURCE_006",
                         ) from e
-                    error = self._create_io_error(contract_file, e)
+                    error = _create_io_error(contract_file, e)
                     logger.warning(
                         "Failed to read contract file, continuing in graceful mode: %s",
-                        self._sanitize_path_for_logging(contract_file),
+                        _sanitize_path_for_logging(contract_file),
                         extra={
                             "contract_file": str(contract_file),
                             "error_type": "io_error",
@@ -446,7 +636,8 @@ class HandlerContractSource(ProtocolContractSource):
             ModelHandlerDescriptor created from the contract.
 
         Raises:
-            ModelOnexError: If contract file exceeds MAX_CONTRACT_SIZE (10MB).
+            ModelOnexError: If contract file exceeds MAX_CONTRACT_SIZE (10MB),
+                or if the version string in the contract is invalid.
             yaml.YAMLError: If YAML parsing fails.
             ValidationError: If contract validation fails.
         """
@@ -477,150 +668,40 @@ class HandlerContractSource(ProtocolContractSource):
         # Validate against ModelHandlerContract
         contract = ModelHandlerContract.model_validate(raw_data)
 
+        # TODO [OMN-1420]: Extract handler_class from ModelHandlerContract
+        #
+        # handler_contract.yaml files include a `handler_class` field for dynamic import
+        # (e.g., "omnibase_infra.handlers.handler_consul.HandlerConsul"), but
+        # ModelHandlerContract from omnibase_core does not have this field yet.
+        #
+        # Once ModelHandlerContract is updated to include handler_class, this code
+        # should be changed from:
+        #     handler_class=raw_data.get("handler_class")
+        # to:
+        #     handler_class=contract.handler_class
+        #
+        # For now, extract directly from raw YAML data to support dynamic handler loading.
+        # See: https://linear.app/omninode/issue/OMN-1420
+        handler_class = (
+            raw_data.get("handler_class") if isinstance(raw_data, dict) else None
+        )
+
+        # Use contract_version directly - it's already a ModelSemVer from Pydantic validation
         # Transform to descriptor
         return ModelHandlerDescriptor(
             handler_id=contract.handler_id,
             name=contract.name,
-            version=contract.version,
-            handler_kind=contract.descriptor.handler_kind,
+            version=contract.contract_version,
+            handler_kind=cast(
+                "LiteralHandlerKind", contract.descriptor.node_archetype.value
+            ),
             input_model=contract.input_model,
             output_model=contract.output_model,
             description=contract.description,
+            handler_class=handler_class,
             contract_path=str(contract_path),
         )
 
-    def _create_parse_error(
-        self,
-        contract_path: Path,
-        error: yaml.YAMLError,
-    ) -> ModelHandlerValidationError:
-        """Create a validation error for YAML parse failures.
-
-        Args:
-            contract_path: Path to the failing contract file.
-            error: The YAML parsing error.
-
-        Returns:
-            ModelHandlerValidationError with parse error details.
-        """
-        handler_identity = ModelHandlerIdentifier.from_handler_id(
-            f"unknown@{contract_path.name}"
-        )
-
-        return ModelHandlerValidationError(
-            error_type=EnumHandlerErrorType.CONTRACT_PARSE_ERROR,
-            rule_id="CONTRACT-001",
-            handler_identity=handler_identity,
-            source_type=EnumHandlerSourceType.CONTRACT,
-            message=f"Failed to parse YAML in {self._sanitize_path_for_logging(contract_path)}: {error}",
-            remediation_hint="Check YAML syntax and ensure proper indentation",
-            file_path=str(contract_path),
-        )
-
-    def _create_validation_error(
-        self,
-        contract_path: Path,
-        error: ValidationError,
-    ) -> ModelHandlerValidationError:
-        """Create a validation error for contract validation failures.
-
-        Args:
-            contract_path: Path to the failing contract file.
-            error: The Pydantic validation error.
-
-        Returns:
-            ModelHandlerValidationError with validation details.
-        """
-        handler_identity = ModelHandlerIdentifier.from_handler_id(
-            f"unknown@{contract_path.name}"
-        )
-
-        # Extract first error detail for remediation hint
-        error_details = error.errors()
-        if error_details:
-            first_error = error_details[0]
-            field_loc = " -> ".join(str(x) for x in first_error.get("loc", ()))
-            error_msg = str(first_error.get("msg", "validation failed"))
-        else:
-            field_loc = "unknown"
-            error_msg = "validation failed"
-
-        return ModelHandlerValidationError(
-            error_type=EnumHandlerErrorType.CONTRACT_VALIDATION_ERROR,
-            rule_id="CONTRACT-002",
-            handler_identity=handler_identity,
-            source_type=EnumHandlerSourceType.CONTRACT,
-            message=f"Contract validation failed in {self._sanitize_path_for_logging(contract_path)}: {error_msg} at {field_loc}",
-            remediation_hint=f"Check the '{field_loc}' field in the contract",
-            file_path=str(contract_path),
-        )
-
-    def _create_size_limit_error(
-        self,
-        contract_path: Path,
-        file_size: int,
-    ) -> ModelHandlerValidationError:
-        """Create a validation error for file size limit violations.
-
-        Args:
-            contract_path: Path to the oversized contract file.
-            file_size: The actual file size in bytes.
-
-        Returns:
-            ModelHandlerValidationError with size limit details.
-        """
-        handler_identity = ModelHandlerIdentifier.from_handler_id(
-            f"unknown@{contract_path.name}"
-        )
-
-        return ModelHandlerValidationError(
-            error_type=EnumHandlerErrorType.CONTRACT_VALIDATION_ERROR,
-            rule_id="CONTRACT-003",
-            handler_identity=handler_identity,
-            source_type=EnumHandlerSourceType.CONTRACT,
-            message=(
-                f"Contract file {self._sanitize_path_for_logging(contract_path)} exceeds size limit: "
-                f"{file_size} bytes (max: {MAX_CONTRACT_SIZE} bytes)"
-            ),
-            remediation_hint=(
-                f"Reduce contract file size to under {MAX_CONTRACT_SIZE // (1024 * 1024)}MB. "
-                "Consider splitting into multiple contracts if needed."
-            ),
-            file_path=str(contract_path),
-        )
-
-    def _create_io_error(
-        self,
-        contract_path: Path,
-        error: OSError,
-    ) -> ModelHandlerValidationError:
-        """Create a validation error for I/O failures.
-
-        Args:
-            contract_path: Path to the contract file that failed to read.
-            error: The I/O error encountered.
-
-        Returns:
-            ModelHandlerValidationError with I/O error details.
-        """
-        handler_identity = ModelHandlerIdentifier.from_handler_id(
-            f"unknown@{contract_path.name}"
-        )
-
-        # OSError.strerror may be None for some error types (e.g., custom subclasses),
-        # so use str(error) as a fallback to ensure we always have an error message
-        error_message = error.strerror or str(error)
-
-        return ModelHandlerValidationError(
-            error_type=EnumHandlerErrorType.CONTRACT_PARSE_ERROR,
-            rule_id="CONTRACT-004",
-            handler_identity=handler_identity,
-            source_type=EnumHandlerSourceType.CONTRACT,
-            message=f"Failed to read contract file: {error_message}",
-            remediation_hint="Check file permissions and ensure the file exists",
-            file_path=str(contract_path),
-        )
-
     def _log_discovery_results(
         self,
         discovered_count: int,

omnibase_infra/runtime/handler_identity.py

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Identity Utilities for HYBRID Mode Resolution.
+
+This module provides the `handler_identity()` function used by both bootstrap
+and contract sources to generate consistent handler IDs. This enables per-handler
+identity matching in HYBRID mode.
+
+The Problem:
+    Prior to this module, contract-discovered handlers used a "bootstrap." prefix
+    for handler_id to enable HYBRID mode identity matching. This was semantically
+    confusing because "bootstrap" reads like "where it came from," not "what it is."
+
+The Solution:
+    A neutral "proto." prefix that indicates this is a **protocol identity namespace**,
+    not a source indicator. Both HandlerBootstrapSource and PluginLoaderContractSource
+    use this shared helper to generate consistent IDs.
+
+Example:
+    >>> from omnibase_infra.runtime.handler_identity import handler_identity
+    >>> handler_identity("consul")
+    'proto.consul'
+    >>> handler_identity("http")
+    'proto.http'
+
+See Also:
+    - HandlerSourceResolver._resolve_hybrid(): Resolution logic that compares handler_id
+    - HandlerBootstrapSource: Uses this to generate bootstrap handler IDs
+    - PluginLoaderContractSource: Uses this for contract-discovered handlers
+
+Part of OMN-1095: Handler Source Mode Feature Flag / Bootstrap Contract Hybrid.
+
+.. versionadded:: 0.7.0
+    Introduced to fix handler ID namespace confusion.
+"""
+
+from __future__ import annotations
+
+# Prefix used for handler identity in HYBRID mode resolution.
+# This is a protocol namespace, NOT a source indicator.
+# Both bootstrap and contract sources use this prefix.
+HANDLER_IDENTITY_PREFIX = "proto"
+
+
+def handler_identity(protocol_type: str) -> str:
+    """Generate stable handler identity for HYBRID mode resolution.
+
+    Both bootstrap and contract sources use this to generate consistent IDs,
+    enabling per-handler identity matching in HYBRID mode. When both sources
+    provide a handler with the same identity, the resolver applies precedence
+    rules (contract wins by default, or bootstrap wins if allow_bootstrap_override=True).
+
+    The "proto." prefix indicates this is a **protocol identity namespace**, not
+    a source origin indicator. Contract-discovered handlers use this prefix
+    specifically so they can be compared against bootstrap-discovered handlers
+    with the same protocol_type.
+
+    Args:
+        protocol_type: The protocol type (e.g., "consul", "http", "db", "vault", "mcp").
+
+    Returns:
+        Stable handler identity string (e.g., "proto.consul", "proto.http").
+
+    Example:
+        >>> handler_identity("consul")
+        'proto.consul'
+        >>> handler_identity("http")
+        'proto.http'
+
+    See Also:
+        HandlerSourceResolver._resolve_hybrid() for resolution logic that uses
+        these identities to determine which handler wins when both sources
+        provide handlers with the same identity.
+    """
+    return f"{HANDLER_IDENTITY_PREFIX}.{protocol_type}"
+
+
+__all__ = [
+    "HANDLER_IDENTITY_PREFIX",
+    "handler_identity",
+]