mdb-engine 0.1.6__py3-none-any.whl → 0.4.12__py3-none-any.whl

mdb_engine/exceptions.py

@@ -5,7 +5,7 @@ These exceptions provide more specific error types while maintaining
 backward compatibility with RuntimeError.
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 class MongoDBEngineError(RuntimeError):
@@ -21,7 +21,7 @@ class MongoDBEngineError(RuntimeError):
                  collection_name, etc.)
     """
 
-    def __init__(self, message: str, context: Optional[Dict[str, Any]] = None) -> None:
+    def __init__(self, message: str, context: dict[str, Any] | None = None) -> None:
         """
         Initialize the exception.
 
@@ -58,9 +58,9 @@ class InitializationError(MongoDBEngineError):
     def __init__(
         self,
         message: str,
-        mongo_uri: Optional[str] = None,
-        db_name: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None,
+        mongo_uri: str | None = None,
+        db_name: str | None = None,
+        context: dict[str, Any] | None = None,
     ) -> None:
         """
         Initialize the initialization error.
@@ -99,10 +99,10 @@ class ManifestValidationError(MongoDBEngineError):
     def __init__(
         self,
         message: str,
-        error_paths: Optional[List[str]] = None,
-        manifest_slug: Optional[str] = None,
-        schema_version: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None,
+        error_paths: list[str] | None = None,
+        manifest_slug: str | None = None,
+        schema_version: str | None = None,
+        context: dict[str, Any] | None = None,
     ) -> None:
         """
         Initialize the manifest validation error.
@@ -144,9 +144,9 @@ class ConfigurationError(MongoDBEngineError):
     def __init__(
         self,
         message: str,
-        config_key: Optional[str] = None,
-        config_value: Optional[Any] = None,
-        context: Optional[Dict[str, Any]] = None,
+        config_key: str | None = None,
+        config_value: Any | None = None,
+        context: dict[str, Any] | None = None,
     ) -> None:
         """
         Initialize the configuration error.
@@ -165,3 +165,95 @@ class ConfigurationError(MongoDBEngineError):
         super().__init__(message, context=context)
         self.config_key = config_key
         self.config_value = config_value
+
+
+class QueryValidationError(MongoDBEngineError):
+    """
+    Raised when a query fails validation checks.
+
+    This exception is raised when a query contains dangerous operators,
+    exceeds complexity limits, or violates security policies.
+
+    Attributes:
+        message: Error message
+        query_type: Type of query that failed (filter, pipeline, etc.)
+        operator: Dangerous operator that was found (if applicable)
+        path: JSON path where the issue was found (if applicable)
+        context: Additional context information
+    """
+
+    def __init__(
+        self,
+        message: str,
+        query_type: str | None = None,
+        operator: str | None = None,
+        path: str | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        """
+        Initialize the query validation error.
+
+        Args:
+            message: Error message
+            query_type: Type of query that failed (filter, pipeline, etc.)
+            operator: Dangerous operator that was found (if applicable)
+            path: JSON path where the issue was found (if applicable)
+            context: Additional context information
+        """
+        context = context or {}
+        if query_type:
+            context["query_type"] = query_type
+        if operator:
+            context["operator"] = operator
+        if path:
+            context["path"] = path
+        super().__init__(message, context=context)
+        self.query_type = query_type
+        self.operator = operator
+        self.path = path
+
+
+class ResourceLimitExceeded(MongoDBEngineError):
+    """
+    Raised when a resource limit is exceeded.
+
+    This exception is raised when queries exceed timeouts, result sizes,
+    or other resource limits.
+
+    Attributes:
+        message: Error message
+        limit_type: Type of limit that was exceeded (timeout, size, etc.)
+        limit_value: The limit value that was exceeded
+        actual_value: The actual value that exceeded the limit
+        context: Additional context information
+    """
+
+    def __init__(
+        self,
+        message: str,
+        limit_type: str | None = None,
+        limit_value: Any | None = None,
+        actual_value: Any | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        """
+        Initialize the resource limit exceeded error.
+
+        Args:
+            message: Error message
+            limit_type: Type of limit that was exceeded (timeout, size, etc.)
+            limit_value: The limit value that was exceeded
+            actual_value: The actual value that exceeded the limit
+            context: Additional context information
+        """
+        context = context or {}
+        if limit_type:
+            context["limit_type"] = limit_type
+        if limit_value is not None:
+            context["limit_value"] = limit_value
+        if actual_value is not None:
+            context["actual_value"] = actual_value
+        super().__init__(message, context=context)
+        self.limit_type = limit_type
+        self.limit_value = limit_value
+        self.actual_value = actual_value

mdb_engine/indexes/README.md

@@ -573,7 +573,7 @@ try:
         collection_name="users",
         index_definitions=index_definitions
     )
-except Exception as e:
+except (PyMongoError, ValueError, TypeError) as e:
     logger.error(f"Failed to create indexes: {e}", exc_info=True)
     raise
 ```
@@ -613,12 +613,20 @@ index_definitions = [
     }
 ]
 
-await run_index_creation_for_collection(
-    db=engine.mongo_db,
-    slug="my_app",
-    collection_name="users",
-    index_definitions=index_definitions
-)
+# Get scoped database and collection
+db = engine.get_scoped_db("my_app")
+collection = db.users
+
+# Use collection.index_manager for index operations
+index_manager = collection.index_manager
+for index_def in index_definitions:
+    if index_def["type"] == "regular":
+        await index_manager.create_index(
+            keys=list(index_def["keys"].items()),
+            name=index_def.get("name"),
+            **index_def.get("options", {})
+        )
+    # Handle other index types similarly...
 ```
 
 ### Multiple Collections
@@ -635,13 +643,22 @@ collections_with_indexes = {
     ]
 }
 
+# Get scoped database
+db = engine.get_scoped_db("my_app")
+
+# Use collection.index_manager for each collection
 for collection_name, index_definitions in collections_with_indexes.items():
-    await run_index_creation_for_collection(
-        db=engine.mongo_db,
-        slug="my_app",
-        collection_name=collection_name,
-        index_definitions=index_definitions
-    )
+    collection = getattr(db, collection_name)
+    index_manager = collection.index_manager
+    
+    for index_def in index_definitions:
+        if index_def["type"] == "regular":
+            await index_manager.create_index(
+                keys=list(index_def["keys"].items()),
+                name=index_def.get("name"),
+                **index_def.get("options", {})
+            )
+        # Handle other index types similarly...
 ```
 
 ## Related Modules

mdb_engine/indexes/__init__.py

@@ -8,6 +8,7 @@ This module is part of MDB_ENGINE - MongoDB Engine.
 
 # Re-export index managers from database module for convenience
 from ..database.scoped_wrapper import AsyncAtlasIndexManager, AutoIndexManager
+
 # Export high-level management functions
 from .manager import normalize_json_def, run_index_creation_for_collection
 

mdb_engine/indexes/helpers.py

@@ -6,14 +6,14 @@ in index creation and management.
 """
 
 import logging
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
 
 def normalize_keys(
-    keys: Union[Dict[str, Any], List[Tuple[str, Any]]]
-) -> List[Tuple[str, Any]]:
+    keys: dict[str, Any] | list[tuple[str, Any]],
+) -> list[tuple[str, Any]]:
     """
     Normalize index keys to a consistent format.
 
@@ -28,7 +28,7 @@ def normalize_keys(
     return keys
 
 
-def keys_to_dict(keys: Union[Dict[str, Any], List[Tuple[str, Any]]]) -> Dict[str, Any]:
+def keys_to_dict(keys: dict[str, Any] | list[tuple[str, Any]]) -> dict[str, Any]:
     """
     Convert index keys to dictionary format for comparison.
 
@@ -43,7 +43,7 @@ def keys_to_dict(keys: Union[Dict[str, Any], List[Tuple[str, Any]]]) -> Dict[str
     return {k: v for k, v in keys}
 
 
-def is_id_index(keys: Union[Dict[str, Any], List[Tuple[str, Any]]]) -> bool:
+def is_id_index(keys: dict[str, Any] | list[tuple[str, Any]]) -> bool:
     """
     Check if index keys target the _id field (which MongoDB creates automatically).
 
@@ -63,10 +63,10 @@ def is_id_index(keys: Union[Dict[str, Any], List[Tuple[str, Any]]]) -> bool:
 async def check_and_update_index(
     index_manager: Any,
     index_name: str,
-    expected_keys: Union[Dict[str, Any], List[Tuple[str, Any]]],
-    expected_options: Optional[Dict[str, Any]] = None,
+    expected_keys: dict[str, Any] | list[tuple[str, Any]],
+    expected_options: dict[str, Any] | None = None,
     log_prefix: str = "",
-) -> Tuple[bool, Optional[Dict[str, Any]]]:
+) -> tuple[bool, dict[str, Any] | None]:
     """
     Check if an index exists and matches the expected definition.
 
@@ -118,11 +118,11 @@ async def check_and_update_index(
 
 
 def validate_index_definition_basic(
-    index_def: Dict[str, Any],
+    index_def: dict[str, Any],
     index_name: str,
-    required_fields: List[str],
+    required_fields: list[str],
     log_prefix: str = "",
-) -> Tuple[bool, Optional[str]]:
+) -> tuple[bool, str | None]:
     """
     Basic validation for index definitions.