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

mdb_engine/embeddings/__init__.py

@@ -35,15 +35,23 @@ Example EmbeddingService usage:
         return {"embeddings": embeddings}
 """
 
-from .dependencies import (create_embedding_dependency,
-                           get_embedding_service_dep,
-                           get_embedding_service_dependency,
-                           get_embedding_service_for_app, get_global_engine,
-                           set_global_engine)
-from .service import (AzureOpenAIEmbeddingProvider, BaseEmbeddingProvider,
-                      EmbeddingProvider, EmbeddingService,
-                      EmbeddingServiceError, OpenAIEmbeddingProvider,
-                      get_embedding_service)
+from .dependencies import (
+    create_embedding_dependency,
+    get_embedding_service_dep,
+    get_embedding_service_dependency,
+    get_embedding_service_for_app,
+    get_global_engine,
+    set_global_engine,
+)
+from .service import (
+    AzureOpenAIEmbeddingProvider,
+    BaseEmbeddingProvider,
+    EmbeddingProvider,
+    EmbeddingService,
+    EmbeddingServiceError,
+    OpenAIEmbeddingProvider,
+    get_embedding_service,
+)
 
 __all__ = [
     "EmbeddingService",

mdb_engine/embeddings/dependencies.py

@@ -147,9 +147,7 @@ def create_embedding_dependency(app_slug: str, engine: Optional[Any] = None):
                     "embedding dependencies are installed.",
                 )
             else:
-                raise RuntimeError(
-                    f"Embedding service not available for app '{app_slug}'"
-                )
+                raise RuntimeError(f"Embedding service not available for app '{app_slug}'")
         return embedding_service
 
     return _get_embedding_service

mdb_engine/embeddings/service.py

@@ -134,7 +134,7 @@ class OpenAIEmbeddingProvider(BaseEmbeddingProvider):
             ConnectionError,
             OSError,
         ) as e:
-            logger.error(f"OpenAI embedding failed: {e}")
+            logger.exception(f"OpenAI embedding failed: {e}")
             raise EmbeddingServiceError(f"OpenAI embedding failed: {str(e)}") from e
 
 
@@ -217,10 +217,8 @@ class AzureOpenAIEmbeddingProvider(BaseEmbeddingProvider):
             ConnectionError,
             OSError,
         ) as e:
-            logger.error(f"Azure OpenAI embedding failed: {e}")
-            raise EmbeddingServiceError(
-                f"Azure OpenAI embedding failed: {str(e)}"
-            ) from e
+            logger.exception(f"Azure OpenAI embedding failed: {e}")
+            raise EmbeddingServiceError(f"Azure OpenAI embedding failed: {str(e)}") from e
 
 
 def _detect_provider_from_env() -> str:
@@ -281,24 +279,16 @@ class EmbeddingProvider:
         else:
             # Auto-detect provider from environment variables
             provider_type = _detect_provider_from_env()
-            default_model = (config or {}).get(
-                "default_embedding_model", "text-embedding-3-small"
-            )
+            default_model = (config or {}).get("default_embedding_model", "text-embedding-3-small")
 
             if provider_type == "azure":
-                self.embedding_provider = AzureOpenAIEmbeddingProvider(
-                    default_model=default_model
-                )
+                self.embedding_provider = AzureOpenAIEmbeddingProvider(default_model=default_model)
                 logger.info(
                     f"Auto-detected Azure OpenAI embedding provider (model: {default_model})"
                 )
             else:
-                self.embedding_provider = OpenAIEmbeddingProvider(
-                    default_model=default_model
-                )
-                logger.info(
-                    f"Auto-detected OpenAI embedding provider (model: {default_model})"
-                )
+                self.embedding_provider = OpenAIEmbeddingProvider(default_model=default_model)
+                logger.info(f"Auto-detected OpenAI embedding provider (model: {default_model})")
 
         # Store config for potential future use
         self.config = config or {}
@@ -341,7 +331,7 @@ class EmbeddingProvider:
             return vectors
 
         except (AttributeError, TypeError, ValueError, RuntimeError, KeyError) as e:
-            logger.error(f"EMBED_FAILED: {str(e)}")
+            logger.exception(f"EMBED_FAILED: {str(e)}")
             raise EmbeddingServiceError(f"Embedding failed: {str(e)}") from e
 
 
@@ -573,7 +563,7 @@ class EmbeddingService:
             ConnectionError,
             OSError,
         ) as e:
-            logger.error(f"Failed to generate embeddings for {source_id}: {e}")
+            logger.exception(f"Failed to generate embeddings for {source_id}: {e}")
             raise EmbeddingServiceError(f"Embedding generation failed: {str(e)}") from e
 
         if len(vectors) != len(chunks):
@@ -614,9 +604,7 @@ class EmbeddingService:
                 result = await collection.insert_many(documents_to_insert)
                 inserted_count = len(result.inserted_ids)
 
-            logger.info(
-                f"Successfully inserted {inserted_count} documents for source: {source_id}"
-            )
+            logger.info(f"Successfully inserted {inserted_count} documents for source: {source_id}")
 
             return {
                 "chunks_created": len(chunks),
@@ -632,9 +620,7 @@ class EmbeddingService:
             KeyError,
             ConnectionError,
         ) as e:
-            logger.error(
-                f"Failed to store documents for {source_id}: {e}", exc_info=True
-            )
+            logger.error(f"Failed to store documents for {source_id}: {e}", exc_info=True)
             raise EmbeddingServiceError(f"Storage failed: {str(e)}") from e
 
     async def process_text(

mdb_engine/exceptions.py

@@ -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: Optional[str] = None,
+        operator: Optional[str] = None,
+        path: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = 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: Optional[str] = None,
+        limit_value: Optional[Any] = None,
+        actual_value: Optional[Any] = None,
+        context: Optional[Dict[str, Any]] = 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

@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 
 def normalize_keys(
-    keys: Union[Dict[str, Any], List[Tuple[str, Any]]]
+    keys: Union[Dict[str, Any], List[Tuple[str, Any]]],
 ) -> List[Tuple[str, Any]]:
     """
     Normalize index keys to a consistent format.