neuroglia-python 0.7.4__tar.gz → 0.7.5__tar.gz

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroglia-python
-Version: 0.7.4
+Version: 0.7.5
 Summary: Port from .NET to Python of the Neuroglia Framework
 License: Apache
 License-File: LICENSE

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.7.4"
+version = "0.7.5"
 description = "Port from .NET to Python of the Neuroglia Framework"
 authors = ["Charles d'Avernas <charles.davernas@neuroglia.io>", "Bruno van de Werve <bvandewe@gmail.com>"]
 license = "Apache"

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/src/neuroglia/__init__.py

@@ -62,7 +62,7 @@ __all__ = [
 ]
 
 # Framework metadata
-__version__ = "0.7.4"
+__version__ = "0.7.5"
 __author__ = "Neuroglia Team"
 __email__ = "team@neuroglia.io"
 __license__ = "Apache"

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/src/neuroglia/data/infrastructure/event_sourcing/event_sourcing_repository.py

@@ -113,10 +113,20 @@ class EventSourcingRepository(Generic[TAggregate, TKey], Repository[TAggregate,
         return self._eventstore.contains_stream(self._build_stream_id_for(id))
 
     async def get_async(self, id: TKey) -> Optional[TAggregate]:
-        """Gets the aggregate with the specified id, if any"""
+        """
+        Gets the aggregate with the specified id, if any.
+
+        Returns None if the stream does not exist.
+        """
         stream_id = self._build_stream_id_for(id)
-        events = await self._eventstore.read_async(stream_id, StreamReadDirection.FORWARDS, 0)
-        return self._aggregator.aggregate(events, self.__orig_class__.__args__[0])
+        try:
+            events = await self._eventstore.read_async(stream_id, StreamReadDirection.FORWARDS, 0)
+            if not events:
+                return None
+            return self._aggregator.aggregate(events, self.__orig_class__.__args__[0])
+        except Exception:
+            # If stream doesn't exist or any other error occurs, return None
+            return None
 
     async def _do_add_async(self, aggregate: TAggregate) -> TAggregate:
         """Adds and persists the specified aggregate"""

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/src/neuroglia/data/infrastructure/mongo/mongo_repository.py

@@ -38,8 +38,8 @@ class MongoRepositoryOptions(Generic[TEntity, TKey]):
 class MongoQuery(Generic[T], Queryable[T]):
     """Represents a Mongo query"""
 
-    def __init__(self, query_provider: "MongoQueryProvider", expression: Optional[expr] = None):
-        super().__init__(query_provider, expression)
+    def __init__(self, query_provider: "MongoQueryProvider", expression: Optional[expr] = None, element_type: Optional[type] = None):
+        super().__init__(query_provider, expression, element_type)
 
 
 class MongoQueryBuilder(NodeVisitor):
@@ -114,7 +114,7 @@ class MongoQueryProvider(QueryProvider):
     _collection: Collection
 
     def create_query(self, element_type: type, expression: expr) -> Queryable:
-        return MongoQuery[element_type](self, expression)
+        return MongoQuery(self, expression, element_type)
 
     def execute(self, expression: expr, query_type: type) -> Any:
         query = MongoQueryBuilder(self._collection, JavaScriptExpressionTranslator()).build(expression)

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/src/neuroglia/data/infrastructure/mongo/motor_query.py

@@ -64,15 +64,16 @@ class MotorQuery(Generic[T], Queryable[T]):
         ```
     """
 
-    def __init__(self, query_provider: "MotorQueryProvider", expression: Optional[expr] = None):
+    def __init__(self, query_provider: "MotorQueryProvider", expression: Optional[expr] = None, element_type: Optional[type] = None):
         """
         Initialize a Motor query.
 
         Args:
             query_provider: The Motor query provider
             expression: Optional AST expression for the query
+            element_type: Optional element type (used for chaining to preserve type info)
         """
-        super().__init__(query_provider, expression)
+        super().__init__(query_provider, expression, element_type)
 
     async def to_list_async(self) -> list[T]:
         """
@@ -319,9 +320,9 @@ class MotorQueryProvider(QueryProvider):
             expression: AST expression for the query
 
         Returns:
-            New MotorQuery instance
+            New MotorQuery instance with element_type propagated
         """
-        return MotorQuery(self, expression)
+        return MotorQuery(self, expression, element_type)
 
     def execute(self, expression: expr, query_type: type) -> Any:
         """

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/src/neuroglia/data/infrastructure/mongo/motor_repository.py

@@ -578,31 +578,68 @@ class MotorRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
 
         return entities
 
-    async def find_async(self, filter_dict: dict) -> list[TEntity]:
+    async def find_async(
+        self,
+        filter_dict: dict,
+        sort: Optional[list[tuple[str, int]]] = None,
+        limit: Optional[int] = None,
+        skip: Optional[int] = None,
+        projection: Optional[dict] = None,
+    ) -> list[TEntity]:
         """
-        Find entities matching a MongoDB filter query.
+        Find entities matching a MongoDB filter query with optional sorting, pagination, and projection.
 
-        This provides direct access to MongoDB's query language for complex queries.
+        This provides direct access to MongoDB's query language for complex queries
+        with full support for cursor operations.
 
         Args:
             filter_dict: MongoDB query filter (e.g., {"state.email": "user@example.com"})
+            sort: List of (field, direction) tuples. Direction: 1 for ascending, -1 for descending.
+                  Example: [("name", 1), ("created_at", -1)]
+            limit: Maximum number of documents to return
+            skip: Number of documents to skip (for pagination)
+            projection: Fields to include/exclude. Example: {"name": 1, "email": 1}
 
         Returns:
             List of entities matching the filter
 
-        Example:
+        Examples:
             ```python
             # Find all active users
             active_users = await repository.find_async({"state.is_active": True})
 
-            # Find users by email domain
-            gmail_users = await repository.find_async({
-                "state.email": {"$regex": "@gmail.com$"}
-            })
+            # Find users by email domain with sorting
+            gmail_users = await repository.find_async(
+                {"state.email": {"$regex": "@gmail.com$"}},
+                sort=[("state.name", 1)]
+            )
+
+            # Paginated query with sorting
+            page_2_users = await repository.find_async(
+                {"state.is_active": True},
+                sort=[("state.created_at", -1)],
+                skip=20,
+                limit=10
+            )
+
+            # Query with field projection (only return specific fields)
+            users = await repository.find_async(
+                {"state.is_active": True},
+                projection={"state.name": 1, "state.email": 1}
+            )
             ```
         """
+        cursor = self.collection.find(filter_dict, projection)
+
+        if sort:
+            cursor = cursor.sort(sort)
+        if skip:
+            cursor = cursor.skip(skip)
+        if limit:
+            cursor = cursor.limit(limit)
+
         entities = []
-        async for doc in self.collection.find(filter_dict):
+        async for doc in cursor:
             entity = self._deserialize_entity(doc)
             entities.append(entity)
 
@@ -631,6 +668,58 @@ class MotorRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
 
         return self._deserialize_entity(doc)
 
+    async def count_async(self, filter_dict: Optional[dict] = None) -> int:
+        """
+        Count documents matching a MongoDB filter query.
+
+        Args:
+            filter_dict: MongoDB query filter. If None or empty dict, counts all documents.
+
+        Returns:
+            Count of documents matching the filter
+
+        Examples:
+            ```python
+            # Count all documents
+            total_count = await repository.count_async()
+
+            # Count with filter
+            active_count = await repository.count_async({"state.is_active": True})
+
+            # Useful for pagination
+            filter_query = {"state.status": "pending"}
+            total_pages = (await repository.count_async(filter_query) + page_size - 1) // page_size
+            ```
+        """
+        filter_dict = filter_dict or {}
+        return await self.collection.count_documents(filter_dict)
+
+    async def exists_async(self, filter_dict: dict) -> bool:
+        """
+        Check if any document matches the MongoDB filter query.
+
+        This is more efficient than count_async for existence checks as it
+        stops after finding the first match.
+
+        Args:
+            filter_dict: MongoDB query filter
+
+        Returns:
+            True if at least one document matches, False otherwise
+
+        Examples:
+            ```python
+            # Check if email already exists
+            email_exists = await repository.exists_async({"state.email": "user@example.com"})
+            if email_exists:
+                raise ValueError("Email already registered")
+
+            # Check if any active users exist
+            has_active = await repository.exists_async({"state.is_active": True})
+            ```
+        """
+        return await self.collection.count_documents(filter_dict, limit=1) > 0
+
     @staticmethod
     def configure(
         builder: ApplicationBuilderBase,

{neuroglia_python-0.7.4 → neuroglia_python-0.7.5}/src/neuroglia/data/queryable.py

@@ -79,9 +79,10 @@ class Queryable(Generic[T]):
         - Repository Pattern Guide: https://bvandewe.github.io/pyneuro/patterns/
     """
 
-    def __init__(self, provider: QueryProvider, expression: Optional[expr] = None):
+    def __init__(self, provider: QueryProvider, expression: Optional[expr] = None, element_type: Optional[type] = None):
         self.provider = provider
         self.expression = ast.Name(id="__query") if expression is None else expression
+        self._element_type = element_type
 
     expression: expr
     """ Gets the expression that is associated with the queryable """
@@ -91,6 +92,10 @@ class Queryable(Generic[T]):
 
     def get_element_type(self) -> type:
         """Gets the type of elements to query against"""
+        # Try explicit element type first (set during chaining)
+        if hasattr(self, "_element_type") and self._element_type is not None:
+            return self._element_type
+        # Fall back to __orig_class__ for initial query creation
         return self.__orig_class__.__args__[0]
 
     def first_or_default(self, predicate: Callable[[T], bool] = None) -> T: