omnibase_infra 0.2.1__py3-none-any.whl

omnibase_infra/handlers/models/model_vault_handler_response.py

@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Vault Handler Response Model.
+
+This module provides the Pydantic model for Vault handler response envelopes
+used by the HandlerVault.
+
+This model provides type consistency with ModelDbQueryResponse and
+ModelConsulHandlerResponse, ensuring all handlers return strongly-typed
+Pydantic models with consistent interfaces (status, payload, correlation_id).
+"""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_infra.enums import EnumResponseStatus
+from omnibase_infra.handlers.models.vault import (
+    ModelVaultHandlerPayload,
+)
+
+
+class ModelVaultHandlerResponse(BaseModel):
+    """Full Vault handler response envelope.
+
+    Provides a standardized response format for Vault operations
+    with status, payload, and correlation tracking.
+
+    This model mirrors ModelDbQueryResponse and ModelConsulHandlerResponse
+    to ensure consistent interfaces across infrastructure handlers.
+
+    Attributes:
+        status: Operation status (EnumResponseStatus.SUCCESS or EnumResponseStatus.ERROR)
+        payload: Vault operation result payload containing operation-specific data
+        correlation_id: UUID for request/response correlation
+
+    Example:
+        >>> from uuid import uuid4
+        >>> from omnibase_infra.enums import EnumResponseStatus
+        >>> from omnibase_infra.handlers.models.vault import (
+        ...     ModelVaultSecretPayload,
+        ...     ModelVaultHandlerPayload,
+        ... )
+        >>> response = ModelVaultHandlerResponse(
+        ...     status=EnumResponseStatus.SUCCESS,
+        ...     payload=ModelVaultHandlerPayload(
+        ...         data=ModelVaultSecretPayload(
+        ...             data={"username": "admin"},
+        ...             metadata={"version": 1},
+        ...         ),
+        ...     ),
+        ...     correlation_id=uuid4(),
+        ... )
+        >>> print(response.status)
+        <EnumResponseStatus.SUCCESS: 'success'>
+        >>> print(response.payload.data.operation_type)
+        <EnumVaultOperationType.READ_SECRET: 'read_secret'>
+    """
+
+    model_config = ConfigDict(
+        strict=True,
+        frozen=True,
+        extra="forbid",
+        from_attributes=True,  # Support pytest-xdist compatibility
+    )
+
+    status: EnumResponseStatus = Field(
+        description="Operation status indicator",
+    )
+    payload: ModelVaultHandlerPayload = Field(
+        description="Vault operation result payload",
+    )
+    correlation_id: UUID = Field(
+        description="UUID for request/response correlation",
+    )
+
+    @property
+    def is_success(self) -> bool:
+        """Check if the response indicates a successful operation.
+
+        Returns:
+            True if status is SUCCESS, False otherwise.
+        """
+        return self.status == EnumResponseStatus.SUCCESS
+
+    @property
+    def is_error(self) -> bool:
+        """Check if the response indicates an error.
+
+        Returns:
+            True if status is ERROR, False otherwise.
+        """
+        return self.status == EnumResponseStatus.ERROR
+
+
+__all__: list[str] = ["ModelVaultHandlerResponse"]

omnibase_infra/handlers/models/qdrant/__init__.py

@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Qdrant handler models package.
+
+Provides strongly-typed Pydantic models for Qdrant vector database operations.
+"""
+
+from omnibase_infra.handlers.models.qdrant.enum_qdrant_operation_type import (
+    EnumQdrantOperationType,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_collection_payload import (
+    ModelQdrantCollectionPayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_delete_payload import (
+    ModelQdrantDeletePayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_handler_config import (
+    ModelQdrantHandlerConfig,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_handler_payload import (
+    ModelQdrantHandlerPayload,
+    QdrantPayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_search_payload import (
+    ModelQdrantSearchPayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_search_result import (
+    ModelQdrantSearchResult,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_upsert_payload import (
+    ModelQdrantUpsertPayload,
+)
+
+__all__: list[str] = [
+    "EnumQdrantOperationType",
+    "ModelQdrantCollectionPayload",
+    "ModelQdrantDeletePayload",
+    "ModelQdrantHandlerConfig",
+    "ModelQdrantHandlerPayload",
+    "ModelQdrantSearchPayload",
+    "ModelQdrantSearchResult",
+    "ModelQdrantUpsertPayload",
+    "QdrantPayload",
+]

omnibase_infra/handlers/models/qdrant/enum_qdrant_operation_type.py

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Qdrant operation type enumeration for discriminated unions."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EnumQdrantOperationType(str, Enum):
+    """Qdrant operation types for handler routing.
+
+    Attributes:
+        CREATE_COLLECTION: Create a new vector collection
+        UPSERT: Insert or update vectors
+        SEARCH: Search for similar vectors
+        DELETE: Delete vectors by ID
+    """
+
+    CREATE_COLLECTION = "qdrant.create_collection"
+    UPSERT = "qdrant.upsert"
+    SEARCH = "qdrant.search"
+    DELETE = "qdrant.delete"
+
+
+__all__: list[str] = ["EnumQdrantOperationType"]

omnibase_infra/handlers/models/qdrant/model_qdrant_collection_payload.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Collection payload model for Qdrant handler."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelQdrantCollectionPayload(BaseModel):
+    """Payload for qdrant.create_collection operation result.
+
+    Attributes:
+        operation_type: Discriminator for payload type
+        collection_name: Name of the created collection
+        vector_size: Dimension of vectors in the collection
+        distance: Distance metric used (cosine, dot, euclidean)
+        success: Whether the creation was successful
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    operation_type: Literal["qdrant.create_collection"] = Field(
+        default="qdrant.create_collection",
+        description="Operation type discriminator",
+    )
+    collection_name: str = Field(
+        description="Name of the created collection"
+    )  # ONEX_EXCLUDE: entity_name - Qdrant uses collection_name as the primary identifier, not a reference
+    vector_size: int = Field(description="Dimension of vectors in the collection")
+    distance: str = Field(
+        default="cosine",
+        description="Distance metric used (cosine, dot, euclidean)",
+    )
+    success: bool = Field(
+        default=True, description="Whether the creation was successful"
+    )
+
+
+__all__: list[str] = ["ModelQdrantCollectionPayload"]

omnibase_infra/handlers/models/qdrant/model_qdrant_delete_payload.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Delete payload model for Qdrant handler."""
+
+from __future__ import annotations
+
+from typing import Literal
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelQdrantDeletePayload(BaseModel):
+    """Payload for qdrant.delete operation result.
+
+    Attributes:
+        operation_type: Discriminator for payload type
+        collection_name: Name of the collection
+        point_ids: IDs of the deleted points
+        success: Whether the delete was successful
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    operation_type: Literal["qdrant.delete"] = Field(
+        default="qdrant.delete",
+        description="Operation type discriminator",
+    )
+    collection_name: str = Field(
+        description="Name of the collection"
+    )  # ONEX_EXCLUDE: entity_name - Qdrant uses collection_name as the primary identifier, not a reference
+    point_ids: list[str | UUID] = Field(description="IDs of the deleted points")
+    success: bool = Field(default=True, description="Whether the delete was successful")
+
+
+__all__: list[str] = ["ModelQdrantDeletePayload"]

omnibase_infra/handlers/models/qdrant/model_qdrant_handler_config.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Configuration model for HandlerQdrant."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelQdrantHandlerConfig(BaseModel):
+    """Configuration for Qdrant handler initialization.
+
+    Attributes:
+        url: Qdrant server URL (e.g., http://localhost:6333)
+        api_key: Optional API key for authentication
+        timeout_seconds: Request timeout in seconds
+        prefer_grpc: Use gRPC instead of HTTP for better performance
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    url: str = Field(
+        default="http://localhost:6333",
+        description="Qdrant server URL",
+    )
+    api_key: str | None = Field(
+        default=None,
+        description="Optional API key for authentication",
+    )
+    timeout_seconds: float = Field(
+        default=30.0,
+        ge=0.1,
+        le=3600.0,
+        description="Request timeout in seconds",
+    )
+    prefer_grpc: bool = Field(
+        default=False,
+        description="Use gRPC instead of HTTP for better performance",
+    )
+
+
+__all__: list[str] = ["ModelQdrantHandlerConfig"]

omnibase_infra/handlers/models/qdrant/model_qdrant_handler_payload.py

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler payload model for Qdrant operations."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
+
+from omnibase_infra.handlers.models.qdrant.model_qdrant_collection_payload import (
+    ModelQdrantCollectionPayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_delete_payload import (
+    ModelQdrantDeletePayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_search_payload import (
+    ModelQdrantSearchPayload,
+)
+from omnibase_infra.handlers.models.qdrant.model_qdrant_upsert_payload import (
+    ModelQdrantUpsertPayload,
+)
+
+
+def _get_qdrant_operation_type(value: object) -> str:
+    """Extract operation_type from Qdrant payload for discriminated union."""
+    if isinstance(value, dict):
+        return str(value.get("operation_type", ""))
+    return getattr(value, "operation_type", "")
+
+
+QdrantPayload = Annotated[
+    Annotated[ModelQdrantCollectionPayload, Tag("qdrant.create_collection")]
+    | Annotated[ModelQdrantUpsertPayload, Tag("qdrant.upsert")]
+    | Annotated[ModelQdrantSearchPayload, Tag("qdrant.search")]
+    | Annotated[ModelQdrantDeletePayload, Tag("qdrant.delete")],
+    Discriminator(_get_qdrant_operation_type),
+]
+"""Discriminated union of all Qdrant payload types."""
+
+
+class ModelQdrantHandlerPayload(BaseModel):
+    """Wrapper for Qdrant handler payloads using discriminated union.
+
+    Attributes:
+        data: The typed payload from the discriminated union
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    data: QdrantPayload = Field(description="The typed payload")
+
+
+__all__: list[str] = ["ModelQdrantHandlerPayload", "QdrantPayload"]

omnibase_infra/handlers/models/qdrant/model_qdrant_search_payload.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Search payload model for Qdrant handler."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_infra.handlers.models.qdrant.model_qdrant_search_result import (
+    ModelQdrantSearchResult,
+)
+
+
+class ModelQdrantSearchPayload(BaseModel):
+    """Payload for qdrant.search operation result.
+
+    Attributes:
+        operation_type: Discriminator for payload type
+        collection_name: Name of the collection searched (ONEX_EXCLUDE: entity_name_pattern)
+        results: List of search results
+        limit: Maximum number of results requested
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    operation_type: Literal["qdrant.search"] = Field(
+        default="qdrant.search",
+        description="Operation type discriminator",
+    )
+    collection_name: str = Field(
+        description="Name of the collection searched"
+    )  # ONEX_EXCLUDE: entity_name - Qdrant uses collection_name as the primary identifier, not a reference
+    results: list[ModelQdrantSearchResult] = Field(
+        default_factory=list,
+        description="List of search results",
+    )
+    limit: int = Field(default=10, description="Maximum number of results requested")
+
+
+__all__: list[str] = ["ModelQdrantSearchPayload"]

omnibase_infra/handlers/models/qdrant/model_qdrant_search_result.py

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Search result model for Qdrant handler."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_infra.models.types import JsonDict
+
+
+class ModelQdrantSearchResult(BaseModel):
+    """Single search result from Qdrant.
+
+    Attributes:
+        id: Point ID
+        score: Similarity score
+        payload: Point payload data
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    id: str | UUID = Field(description="Point ID")
+    score: float = Field(description="Similarity score")
+    payload: JsonDict | None = Field(default=None, description="Point payload data")
+
+
+__all__: list[str] = ["ModelQdrantSearchResult"]

omnibase_infra/handlers/models/qdrant/model_qdrant_upsert_payload.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Upsert payload model for Qdrant handler."""
+
+from __future__ import annotations
+
+from typing import Literal
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelQdrantUpsertPayload(BaseModel):
+    """Payload for qdrant.upsert operation result.
+
+    Attributes:
+        operation_type: Discriminator for payload type
+        collection_name: Name of the collection
+        point_id: ID of the upserted point
+        success: Whether the upsert was successful
+    """
+
+    model_config = ConfigDict(strict=True, frozen=True, extra="forbid")
+
+    operation_type: Literal["qdrant.upsert"] = Field(
+        default="qdrant.upsert",
+        description="Operation type discriminator",
+    )
+    collection_name: str = Field(
+        description="Name of the collection"
+    )  # ONEX_EXCLUDE: entity_name - Qdrant uses collection_name as the primary identifier, not a reference
+    point_id: str | UUID = Field(description="ID of the upserted point")
+    success: bool = Field(default=True, description="Whether the upsert was successful")
+
+
+__all__: list[str] = ["ModelQdrantUpsertPayload"]

omnibase_infra/handlers/models/vault/__init__.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Vault Handler Models Module.
+
+This module exports Pydantic models for Vault handler request/response structures.
+All models are strongly typed to eliminate Any usage.
+
+Exports:
+    EnumVaultOperationType: Discriminator enum for Vault operation types
+    ModelPayloadVault: Base model for registry-managed Vault payloads
+    RegistryPayloadVault: Decorator-based registry for payload type discovery
+    ModelVaultSecretPayload: Payload for vault.read_secret result
+    ModelVaultWritePayload: Payload for vault.write_secret result
+    ModelVaultDeletePayload: Payload for vault.delete_secret result
+    ModelVaultListPayload: Payload for vault.list_secrets result
+    ModelVaultRenewTokenPayload: Payload for vault.renew_token result
+    VaultPayload: Discriminated union of all Vault payload types
+    ModelVaultHandlerPayload: Wrapper containing discriminated union payload
+"""
+
+from omnibase_infra.handlers.models.vault.enum_vault_operation_type import (
+    EnumVaultOperationType,
+)
+from omnibase_infra.handlers.models.vault.model_payload_vault import (
+    ModelPayloadVault,
+)
+from omnibase_infra.handlers.models.vault.model_vault_delete_payload import (
+    ModelVaultDeletePayload,
+)
+from omnibase_infra.handlers.models.vault.model_vault_handler_config import (
+    ModelVaultHandlerConfig,
+)
+from omnibase_infra.handlers.models.vault.model_vault_handler_payload import (
+    ModelVaultHandlerPayload,
+    VaultPayload,
+)
+from omnibase_infra.handlers.models.vault.model_vault_list_payload import (
+    ModelVaultListPayload,
+)
+from omnibase_infra.handlers.models.vault.model_vault_renew_token_payload import (
+    ModelVaultRenewTokenPayload,
+)
+from omnibase_infra.handlers.models.vault.model_vault_retry_config import (
+    ModelVaultRetryConfig,
+)
+from omnibase_infra.handlers.models.vault.model_vault_secret_payload import (
+    ModelVaultSecretPayload,
+)
+from omnibase_infra.handlers.models.vault.model_vault_write_payload import (
+    ModelVaultWritePayload,
+)
+from omnibase_infra.handlers.models.vault.registry_payload_vault import (
+    RegistryPayloadVault,
+)
+
+__all__: list[str] = [
+    "EnumVaultOperationType",
+    "ModelPayloadVault",
+    "ModelVaultDeletePayload",
+    "ModelVaultHandlerConfig",
+    "ModelVaultHandlerPayload",
+    "ModelVaultListPayload",
+    "ModelVaultRenewTokenPayload",
+    "ModelVaultRetryConfig",
+    "ModelVaultSecretPayload",
+    "ModelVaultWritePayload",
+    "RegistryPayloadVault",
+    "VaultPayload",
+]

omnibase_infra/handlers/models/vault/enum_vault_operation_type.py

@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Vault Operation Type Enum.
+
+Defines the discriminator enum for Vault operation types, used in the
+discriminated union for Vault handler responses.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EnumVaultOperationType(str, Enum):
+    """Vault operation type discriminator.
+
+    Each value corresponds to a specific Vault operation type and its
+    associated payload model in the VaultPayload discriminated union.
+
+    Attributes:
+        READ_SECRET: Read secret operation (ModelVaultSecretPayload)
+        WRITE_SECRET: Write secret operation (ModelVaultWritePayload)
+        DELETE_SECRET: Delete secret operation (ModelVaultDeletePayload)
+        LIST_SECRETS: List secrets operation (ModelVaultListPayload)
+        RENEW_TOKEN: Renew token operation (ModelVaultRenewTokenPayload)
+    """
+
+    READ_SECRET = "read_secret"
+    WRITE_SECRET = "write_secret"
+    DELETE_SECRET = "delete_secret"
+    LIST_SECRETS = "list_secrets"
+    RENEW_TOKEN = "renew_token"
+
+
+__all__: list[str] = ["EnumVaultOperationType"]

omnibase_infra/handlers/models/vault/model_payload_vault.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Base Vault payload model for registry-based type resolution.
+
+This module provides:
+- ModelPayloadVault: Base model for all Vault handler payloads
+
+Design Pattern:
+    Instead of maintaining explicit union types like:
+        VaultPayload = ModelVaultSecretPayload | ModelVaultWritePayload | ...
+
+    Payload models self-register via decorator:
+        @RegistryPayloadVault.register("read_secret")
+        class ModelVaultSecretPayload(ModelPayloadVault): ...
+
+    The registry resolves types dynamically during Pydantic validation,
+    enabling new payload types to be added without modifying existing code.
+
+Related:
+    - RegistryPayloadVault: Decorator-based registry for payload type discovery
+    - EnumVaultOperationType: Operation type enum for discriminator
+    - OMN-1007: Union reduction refactoring
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ModelPayloadVault(BaseModel):
+    """Base model for all registry-managed Vault payloads.
+
+    All concrete Vault payload models MUST:
+    1. Inherit from this base class
+    2. Use @RegistryPayloadVault.register("operation_type") decorator
+    3. Define operation_type field with appropriate Literal type
+    4. Be frozen (immutable) for thread safety
+
+    This base class defines the common interface that all payloads share,
+    enabling type-safe access to common fields without type narrowing.
+
+    Example:
+        @RegistryPayloadVault.register("read_secret")
+        class ModelVaultSecretPayload(ModelPayloadVault):
+            operation_type: Literal[EnumVaultOperationType.READ_SECRET]
+            path: str
+            data: dict[str, str]
+            ...
+
+    Attributes:
+        operation_type: Operation type identifier used for type discrimination.
+
+    Related:
+        - RegistryPayloadVault: Registration decorator and type lookup
+        - EnumVaultOperationType: Enum defining valid operation types
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    operation_type: str
+    """Operation type identifier used for type discrimination."""
+
+
+__all__ = [
+    "ModelPayloadVault",
+]

omnibase_infra/handlers/models/vault/model_vault_delete_payload.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Vault Delete Payload Model.
+
+This module provides the Pydantic model for vault.delete_secret operation results.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import ConfigDict, Field
+
+from omnibase_infra.handlers.models.vault.enum_vault_operation_type import (
+    EnumVaultOperationType,
+)
+from omnibase_infra.handlers.models.vault.model_payload_vault import (
+    ModelPayloadVault,
+)
+from omnibase_infra.handlers.models.vault.registry_payload_vault import (
+    RegistryPayloadVault,
+)
+
+
+@RegistryPayloadVault.register("delete_secret")
+class ModelVaultDeletePayload(ModelPayloadVault):
+    """Payload for vault.delete_secret operation result.
+
+    Contains confirmation of secret deletion.
+
+    Attributes:
+        operation_type: Discriminator set to "delete_secret"
+        deleted: Whether the secret was successfully deleted
+
+    Example:
+        >>> payload = ModelVaultDeletePayload(deleted=True)
+        >>> print(payload.deleted)
+        True
+    """
+
+    model_config = ConfigDict(
+        strict=True,
+        frozen=True,
+        extra="forbid",
+        from_attributes=True,
+    )
+
+    operation_type: Literal[EnumVaultOperationType.DELETE_SECRET] = Field(
+        default=EnumVaultOperationType.DELETE_SECRET,
+        description="Operation type discriminator",
+    )
+    deleted: bool = Field(
+        description="Whether the secret was successfully deleted",
+    )
+
+
+__all__: list[str] = ["ModelVaultDeletePayload"]