mdb-engine 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

mdb_engine/observability/health.py

@@ -6,10 +6,11 @@ Provides health check functions for monitoring system status.
 
 import asyncio
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any
 
 from pymongo.errors import (
     ConnectionFailure,
@@ -36,10 +37,10 @@ class HealthCheckResult:
     name: str
     status: HealthStatus
     message: str
-    details: Optional[Dict[str, Any]] = None
+    details: dict[str, Any] | None = None
     timestamp: datetime = field(default_factory=datetime.now)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
         return {
             "name": self.name,
@@ -57,7 +58,7 @@ class HealthChecker:
 
     def __init__(self):
         """Initialize the health checker."""
-        self._checks: List[callable] = []
+        self._checks: list[callable] = []
 
     def register_check(self, check_func: Callable) -> None:
         """
@@ -68,14 +69,14 @@ class HealthChecker:
         """
         self._checks.append(check_func)
 
-    async def check_all(self) -> Dict[str, Any]:
+    async def check_all(self) -> dict[str, Any]:
         """
         Run all registered health checks.
 
         Returns:
             Dictionary with overall status and individual check results
         """
-        results: List[HealthCheckResult] = []
+        results: list[HealthCheckResult] = []
 
         for check_func in self._checks:
             try:
@@ -117,7 +118,7 @@ class HealthChecker:
 
 
 async def check_mongodb_health(
-    mongo_client: Optional[Any], timeout_seconds: float = 5.0
+    mongo_client: Any | None, timeout_seconds: float = 5.0
 ) -> HealthCheckResult:
     """
     Check MongoDB connection health.
@@ -166,7 +167,7 @@ async def check_mongodb_health(
         )
 
 
-async def check_engine_health(engine: Optional[Any]) -> HealthCheckResult:
+async def check_engine_health(engine: Any | None) -> HealthCheckResult:
     """
     Check MongoDB Engine health.
 
@@ -205,7 +206,7 @@ async def check_engine_health(engine: Optional[Any]) -> HealthCheckResult:
 
 
 async def check_pool_health(
-    get_pool_metrics_func: Optional[Callable[[], Any]] = None,
+    get_pool_metrics_func: Callable[[], Any] | None = None,
 ) -> HealthCheckResult:
     """
     Check connection pool health.

mdb_engine/observability/logging.py

@@ -8,25 +8,25 @@ import contextvars
 import logging
 import uuid
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any
 
 # Context variable for correlation ID
-_correlation_id: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+_correlation_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
     "correlation_id", default=None
 )
 
 # Context variable for app context
-_app_context: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+_app_context: contextvars.ContextVar[dict[str, Any] | None] = contextvars.ContextVar(
     "app_context", default=None
 )
 
 
-def get_correlation_id() -> Optional[str]:
+def get_correlation_id() -> str | None:
     """Get the current correlation ID from context."""
     return _correlation_id.get()
 
 
-def set_correlation_id(correlation_id: Optional[str] = None) -> str:
+def set_correlation_id(correlation_id: str | None = None) -> str:
     """
     Set a correlation ID in the current context.
 
@@ -47,7 +47,7 @@ def clear_correlation_id() -> None:
     _correlation_id.set(None)
 
 
-def set_app_context(app_slug: Optional[str] = None, **kwargs: Any) -> None:
+def set_app_context(app_slug: str | None = None, **kwargs: Any) -> None:
     """
     Set app context for logging.
 
@@ -64,14 +64,14 @@ def clear_app_context() -> None:
     _app_context.set(None)
 
 
-def get_logging_context() -> Dict[str, Any]:
+def get_logging_context() -> dict[str, Any]:
     """
     Get current logging context (correlation ID and app context).
 
     Returns:
         Dictionary with context information
     """
-    context: Dict[str, Any] = {
+    context: dict[str, Any] = {
         "timestamp": datetime.now().isoformat(),
     }
 
@@ -91,7 +91,7 @@ class ContextualLoggerAdapter(logging.LoggerAdapter):
     Logger adapter that automatically adds context to log records.
     """
 
-    def process(self, msg: str, kwargs: Dict[str, Any]) -> tuple[str, Dict[str, Any]]:
+    def process(self, msg: str, kwargs: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         """Add context to log records."""
         # Get base context
         context = get_logging_context()
@@ -124,7 +124,7 @@ def log_operation(
     operation: str,
     level: int = logging.INFO,
     success: bool = True,
-    duration_ms: Optional[float] = None,
+    duration_ms: float | None = None,
     **context: Any,
 ) -> None:
     """

mdb_engine/observability/metrics.py

@@ -9,9 +9,10 @@ import logging
 import threading
 import time
 from collections import OrderedDict
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Callable, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -26,7 +27,7 @@ class OperationMetrics:
     min_duration_ms: float = float("inf")
     max_duration_ms: float = 0.0
     error_count: int = 0
-    last_execution: Optional[datetime] = None
+    last_execution: datetime | None = None
 
     @property
     def avg_duration_ms(self) -> float:
@@ -48,7 +49,7 @@ class OperationMetrics:
             self.error_count += 1
         self.last_execution = datetime.now()
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert metrics to dictionary."""
         return {
             "operation": self.operation_name,
@@ -121,7 +122,7 @@ class MetricsCollector:
 
             self._metrics[key].record(duration_ms, success)
 
-    def get_metrics(self, operation_name: Optional[str] = None) -> Dict[str, Any]:
+    def get_metrics(self, operation_name: str | None = None) -> dict[str, Any]:
         """
         Get metrics for operations.
 
@@ -154,7 +155,7 @@ class MetricsCollector:
             "total_operations": total_operations,
         }
 
-    def get_summary(self) -> Dict[str, Any]:
+    def get_summary(self) -> dict[str, Any]:
         """
         Get a summary of all metrics.
 
@@ -170,7 +171,7 @@ class MetricsCollector:
                 }
 
             # Aggregate by base operation name (without tags)
-            aggregated: Dict[str, OperationMetrics] = {}
+            aggregated: dict[str, OperationMetrics] = {}
 
             for _key, metric in self._metrics.items():
                 base_name = metric.operation_name
@@ -217,7 +218,7 @@ class MetricsCollector:
 
 
 # Global metrics collector instance
-_metrics_collector: Optional[MetricsCollector] = None
+_metrics_collector: MetricsCollector | None = None
 
 
 def get_metrics_collector() -> MetricsCollector:

mdb_engine/repositories/base.py

@@ -8,7 +8,7 @@ This allows domain services to work with any data store implementation.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Dict, Generic, List, Optional, TypeVar
+from typing import Any, Generic, TypeVar
 
 from bson import ObjectId
 
@@ -28,11 +28,11 @@ class Entity:
             role: str = "user"
     """
 
-    id: Optional[str] = None
-    created_at: Optional[datetime] = field(default=None)
-    updated_at: Optional[datetime] = field(default=None)
+    id: str | None = None
+    created_at: datetime | None = field(default=None)
+    updated_at: datetime | None = field(default=None)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert entity to dictionary for storage."""
         data = {}
         for key, value in self.__dict__.items():
@@ -48,7 +48,7 @@ class Entity:
         return data
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Entity":
+    def from_dict(cls, data: dict[str, Any]) -> "Entity":
         """Create entity from dictionary (e.g., from database)."""
         if data is None:
             return None
@@ -88,7 +88,7 @@ class Repository(ABC, Generic[T]):
     """
 
     @abstractmethod
-    async def get(self, id: str) -> Optional[T]:
+    async def get(self, id: str) -> T | None:
         """
         Get a single entity by ID.
 
@@ -103,11 +103,11 @@ class Repository(ABC, Generic[T]):
     @abstractmethod
     async def find(
         self,
-        filter: Optional[Dict[str, Any]] = None,
+        filter: dict[str, Any] | None = None,
         skip: int = 0,
         limit: int = 100,
-        sort: Optional[List[tuple]] = None,
-    ) -> List[T]:
+        sort: list[tuple] | None = None,
+    ) -> list[T]:
         """
         Find entities matching a filter.
 
@@ -125,8 +125,8 @@ class Repository(ABC, Generic[T]):
     @abstractmethod
     async def find_one(
         self,
-        filter: Dict[str, Any],
-    ) -> Optional[T]:
+        filter: dict[str, Any],
+    ) -> T | None:
         """
         Find a single entity matching a filter.
 
@@ -152,7 +152,7 @@ class Repository(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    async def add_many(self, entities: List[T]) -> List[str]:
+    async def add_many(self, entities: list[T]) -> list[str]:
         """
         Add multiple entities.
 
@@ -179,7 +179,7 @@ class Repository(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    async def update_fields(self, id: str, fields: Dict[str, Any]) -> bool:
+    async def update_fields(self, id: str, fields: dict[str, Any]) -> bool:
         """
         Update specific fields of an entity.
 
@@ -206,7 +206,7 @@ class Repository(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    async def count(self, filter: Optional[Dict[str, Any]] = None) -> int:
+    async def count(self, filter: dict[str, Any] | None = None) -> int:
         """
         Count entities matching a filter.
 
@@ -242,10 +242,10 @@ class InMemoryRepository(Repository[T]):
 
     def __init__(self, entity_class: type):
         self._entity_class = entity_class
-        self._storage: Dict[str, Dict[str, Any]] = {}
+        self._storage: dict[str, dict[str, Any]] = {}
         self._counter = 0
 
-    async def get(self, id: str) -> Optional[T]:
+    async def get(self, id: str) -> T | None:
         data = self._storage.get(id)
         if data is None:
             return None
@@ -253,11 +253,11 @@ class InMemoryRepository(Repository[T]):
 
     async def find(
         self,
-        filter: Optional[Dict[str, Any]] = None,
+        filter: dict[str, Any] | None = None,
         skip: int = 0,
         limit: int = 100,
-        sort: Optional[List[tuple]] = None,
-    ) -> List[T]:
+        sort: list[tuple] | None = None,
+    ) -> list[T]:
         results = []
         for data in self._storage.values():
             if filter is None or self._matches_filter(data, filter):
@@ -266,7 +266,7 @@ class InMemoryRepository(Repository[T]):
         # Apply skip and limit
         return results[skip : skip + limit]
 
-    async def find_one(self, filter: Dict[str, Any]) -> Optional[T]:
+    async def find_one(self, filter: dict[str, Any]) -> T | None:
         results = await self.find(filter, limit=1)
         return results[0] if results else None
 
@@ -278,7 +278,7 @@ class InMemoryRepository(Repository[T]):
         self._storage[id] = entity.to_dict()
         return id
 
-    async def add_many(self, entities: List[T]) -> List[str]:
+    async def add_many(self, entities: list[T]) -> list[str]:
         return [await self.add(e) for e in entities]
 
     async def update(self, id: str, entity: T) -> bool:
@@ -289,7 +289,7 @@ class InMemoryRepository(Repository[T]):
         self._storage[id] = entity.to_dict()
         return True
 
-    async def update_fields(self, id: str, fields: Dict[str, Any]) -> bool:
+    async def update_fields(self, id: str, fields: dict[str, Any]) -> bool:
         if id not in self._storage:
             return False
         self._storage[id].update(fields)
@@ -302,7 +302,7 @@ class InMemoryRepository(Repository[T]):
         del self._storage[id]
         return True
 
-    async def count(self, filter: Optional[Dict[str, Any]] = None) -> int:
+    async def count(self, filter: dict[str, Any] | None = None) -> int:
         if filter is None:
             return len(self._storage)
         return len(await self.find(filter, limit=999999))
@@ -310,7 +310,7 @@ class InMemoryRepository(Repository[T]):
     async def exists(self, id: str) -> bool:
         return id in self._storage
 
-    def _matches_filter(self, data: Dict[str, Any], filter: Dict[str, Any]) -> bool:
+    def _matches_filter(self, data: dict[str, Any], filter: dict[str, Any]) -> bool:
         """Simple filter matching for testing."""
         for key, value in filter.items():
             if key not in data:

mdb_engine/repositories/mongo.py

@@ -7,7 +7,7 @@ This provides automatic app scoping and security features.
 
 import logging
 from datetime import datetime
-from typing import Any, Dict, Generic, List, Optional, Type, TypeVar
+from typing import Any, Generic, TypeVar
 
 from bson import ObjectId
 
@@ -41,7 +41,7 @@ class MongoRepository(Repository[T], Generic[T]):
     def __init__(
         self,
         collection: Any,  # ScopedCollectionWrapper - avoid import cycle
-        entity_class: Type[T],
+        entity_class: type[T],
     ):
         """
         Initialize the MongoDB repository.
@@ -53,20 +53,20 @@ class MongoRepository(Repository[T], Generic[T]):
         self._collection = collection
         self._entity_class = entity_class
 
-    def _to_entity(self, doc: Optional[Dict[str, Any]]) -> Optional[T]:
+    def _to_entity(self, doc: dict[str, Any] | None) -> T | None:
         """Convert a MongoDB document to an entity."""
         if doc is None:
             return None
         return self._entity_class.from_dict(doc)
 
-    def _to_document(self, entity: T, include_id: bool = False) -> Dict[str, Any]:
+    def _to_document(self, entity: T, include_id: bool = False) -> dict[str, Any]:
         """Convert an entity to a MongoDB document."""
         doc = entity.to_dict()
         if not include_id and "_id" in doc:
             del doc["_id"]
         return doc
 
-    async def get(self, id: str) -> Optional[T]:
+    async def get(self, id: str) -> T | None:
         """Get entity by ID."""
         try:
             object_id = ObjectId(id) if ObjectId.is_valid(id) else id
@@ -78,11 +78,11 @@ class MongoRepository(Repository[T], Generic[T]):
 
     async def find(
         self,
-        filter: Optional[Dict[str, Any]] = None,
+        filter: dict[str, Any] | None = None,
         skip: int = 0,
         limit: int = 100,
-        sort: Optional[List[tuple]] = None,
-    ) -> List[T]:
+        sort: list[tuple] | None = None,
+    ) -> list[T]:
         """Find entities matching a filter."""
         cursor = self._collection.find(filter or {})
 
@@ -96,7 +96,7 @@ class MongoRepository(Repository[T], Generic[T]):
         docs = await cursor.to_list(length=limit)
         return [self._to_entity(doc) for doc in docs]
 
-    async def find_one(self, filter: Dict[str, Any]) -> Optional[T]:
+    async def find_one(self, filter: dict[str, Any]) -> T | None:
         """Find a single entity matching a filter."""
         doc = await self._collection.find_one(filter)
         return self._to_entity(doc)
@@ -112,7 +112,7 @@ class MongoRepository(Repository[T], Generic[T]):
         logger.debug(f"Added {self._entity_class.__name__} with id={entity.id}")
         return entity.id
 
-    async def add_many(self, entities: List[T]) -> List[str]:
+    async def add_many(self, entities: list[T]) -> list[str]:
         """Add multiple entities and return their IDs."""
         now = datetime.utcnow()
         docs = []
@@ -124,7 +124,7 @@ class MongoRepository(Repository[T], Generic[T]):
         result = await self._collection.insert_many(docs)
         ids = [str(id) for id in result.inserted_ids]
 
-        for entity, id in zip(entities, ids):
+        for entity, id in zip(entities, ids, strict=False):
             entity.id = id
 
         logger.debug(f"Added {len(ids)} {self._entity_class.__name__} entities")
@@ -144,7 +144,7 @@ class MongoRepository(Repository[T], Generic[T]):
 
         return result.modified_count > 0
 
-    async def update_fields(self, id: str, fields: Dict[str, Any]) -> bool:
+    async def update_fields(self, id: str, fields: dict[str, Any]) -> bool:
         """Update specific fields of an entity."""
         try:
             object_id = ObjectId(id) if ObjectId.is_valid(id) else id
@@ -167,7 +167,7 @@ class MongoRepository(Repository[T], Generic[T]):
         result = await self._collection.delete_one({"_id": object_id})
         return result.deleted_count > 0
 
-    async def count(self, filter: Optional[Dict[str, Any]] = None) -> int:
+    async def count(self, filter: dict[str, Any] | None = None) -> int:
         """Count entities matching a filter."""
         return await self._collection.count_documents(filter or {})
 
@@ -183,7 +183,7 @@ class MongoRepository(Repository[T], Generic[T]):
 
     # Additional MongoDB-specific methods
 
-    async def aggregate(self, pipeline: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    async def aggregate(self, pipeline: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """
         Run an aggregation pipeline.
 
@@ -198,8 +198,8 @@ class MongoRepository(Repository[T], Generic[T]):
 
     async def update_many(
         self,
-        filter: Dict[str, Any],
-        update: Dict[str, Any],
+        filter: dict[str, Any],
+        update: dict[str, Any],
     ) -> int:
         """
         Update multiple documents matching a filter.
@@ -219,7 +219,7 @@ class MongoRepository(Repository[T], Generic[T]):
         result = await self._collection.update_many(filter, update)
         return result.modified_count
 
-    async def delete_many(self, filter: Dict[str, Any]) -> int:
+    async def delete_many(self, filter: dict[str, Any]) -> int:
         """
         Delete multiple documents matching a filter.
 

mdb_engine/repositories/unit_of_work.py

@@ -6,7 +6,7 @@ The UnitOfWork acts as a factory for repositories and manages their lifecycle.
 """
 
 import logging
-from typing import Any, Dict, Generic, Optional, Type, TypeVar
+from typing import Any, Generic, TypeVar
 
 from .base import Entity, Repository
 from .mongo import MongoRepository
@@ -49,7 +49,7 @@ class UnitOfWork:
     def __init__(
         self,
         db: Any,  # ScopedMongoWrapper - avoid import cycle
-        entity_registry: Optional[Dict[str, Type[Entity]]] = None,
+        entity_registry: dict[str, type[Entity]] | None = None,
     ):
         """
         Initialize the Unit of Work.
@@ -59,10 +59,10 @@ class UnitOfWork:
             entity_registry: Optional mapping of collection names to entity classes
         """
         self._db = db
-        self._repositories: Dict[str, Repository] = {}
-        self._entity_registry: Dict[str, Type[Entity]] = entity_registry or {}
+        self._repositories: dict[str, Repository] = {}
+        self._entity_registry: dict[str, type[Entity]] = entity_registry or {}
 
-    def register_entity(self, collection_name: str, entity_class: Type[Entity]) -> None:
+    def register_entity(self, collection_name: str, entity_class: type[Entity]) -> None:
         """
         Register an entity class for a collection.
 
@@ -77,7 +77,7 @@ class UnitOfWork:
     def repository(
         self,
         name: str,
-        entity_class: Optional[Type[T]] = None,
+        entity_class: type[T] | None = None,
     ) -> Repository[T]:
         """
         Get or create a repository for a collection.