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

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.7.3"
+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.3 → neuroglia_python-0.7.5}/src/neuroglia/__init__.py

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

{neuroglia_python-0.7.3 → 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.3 → 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.3 → 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.3 → 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.3 → neuroglia_python-0.7.5}/src/neuroglia/data/queryable.py

@@ -1,6 +1,5 @@
 import ast
 import inspect
-import os
 from abc import ABC, abstractclassmethod
 from ast import Attribute, Name, NodeTransformer, expr
 from collections.abc import Callable
@@ -80,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 """
@@ -92,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:
@@ -146,7 +150,9 @@ class Queryable(Generic[T]):
 
     def order_by(self, selector: Callable[[T], Any]):
         """Orders the sequence using the specified attribute"""
-        selector_source = self._get_lambda_source_code(selector)
+        frame = inspect.currentframe().f_back
+        frame_info = inspect.getframeinfo(frame)
+        selector_source = self._get_lambda_source_code(selector, frame_info.positions.end_col_offset)
         selector_tree = ast.parse(selector_source)
         selector_lambda_expression = selector_tree.body[0].value
         if not isinstance(selector_lambda_expression.body, Attribute):
@@ -160,7 +166,9 @@ class Queryable(Generic[T]):
 
     def order_by_descending(self, selector: Callable[[T], Any]):
         """Orders the sequence in a descending fashion using the specified attribute"""
-        selector_source = self._get_lambda_source_code(selector)
+        frame = inspect.currentframe().f_back
+        frame_info = inspect.getframeinfo(frame)
+        selector_source = self._get_lambda_source_code(selector, frame_info.positions.end_col_offset)
         selector_tree = ast.parse(selector_source)
         selector_lambda_expression = selector_tree.body[0].value
         if not isinstance(selector_lambda_expression.body, Attribute):
@@ -175,8 +183,9 @@ class Queryable(Generic[T]):
     def select(self, selector: Callable[[T], Any]):
         """Projects each element of a sequence into a new form"""
         frame = inspect.currentframe().f_back
+        frame_info = inspect.getframeinfo(frame)
         variables = {**frame.f_locals}
-        selector_source = self._get_lambda_source_code(selector)
+        selector_source = self._get_lambda_source_code(selector, frame_info.positions.end_col_offset)
         selector_tree = ast.parse(selector_source)
         selector_lambda_expression = selector_tree.body[0].value
         if not isinstance(selector_lambda_expression.body, Attribute) and not isinstance(selector_lambda_expression.body, ast.List):
@@ -239,18 +248,64 @@ class Queryable(Generic[T]):
             function (Callable): The lambda to get the source code of
             max_col_offset (int): The maximum column offset to walk the AST tree for the target lamba
 
+        Returns:
+            Optional[str]: The lambda source code, or None if extraction fails
+
         Notes:
             Credits to https://gist.github.com/Xion/617c1496ff45f3673a5692c3b0e3f75a
+
+            This method handles the case where the lambda is on a continuation line
+            that starts with '.' (common in method chaining). In such cases, the raw
+            source line is invalid Python syntax, so we prepend a dummy identifier
+            to make it parseable.
+
+            For multi-line continuations (backslash or implicit), we only process
+            the first line containing the lambda, as that's sufficient for extraction.
         """
-        source_lines, _ = inspect.getsourcelines(function)
-        if len(source_lines) != 1:
+        try:
+            source_lines, _ = inspect.getsourcelines(function)
+        except (OSError, TypeError) as e:
+            # Cannot extract source (e.g., built-in functions, C extensions)
             return None
-        source_text = os.linesep.join(source_lines).strip()
-        source_ast = ast.parse(source_text)
-        lambda_node = next(
-            (node for node in ast.walk(source_ast) if isinstance(node, ast.Lambda) and node.col_offset <= max_col_offset),
-            None,
-        )
+
+        # For multi-line sources (continuation), use only the first line
+        # The lambda itself is typically on the first line
+        if len(source_lines) == 0:
+            return None
+
+        # Strip the line and remove trailing backslash if present (line continuation)
+        source_text = source_lines[0].strip().rstrip("\\").strip()
+
+        # Handle continuation lines that start with '.' (method chaining)
+        # These are invalid Python syntax on their own
+        offset_adjustment = 0
+        if source_text.startswith("."):
+            source_text = "_" + source_text  # Prepend dummy identifier
+            offset_adjustment = 1
+
+        try:
+            source_ast = ast.parse(source_text)
+        except SyntaxError:
+            return None
+
+        # Adjust max_col_offset if we prepended a dummy identifier
+        # Set to None if not provided to match all lambdas
+        adjusted_max_col_offset = None
+        if max_col_offset is not None:
+            adjusted_max_col_offset = max_col_offset + offset_adjustment
+
+        # Find lambda node within the adjusted column offset
+        if adjusted_max_col_offset is not None:
+            lambda_node = next(
+                (node for node in ast.walk(source_ast) if isinstance(node, ast.Lambda) and node.col_offset <= adjusted_max_col_offset),
+                None,
+            )
+        else:
+            lambda_node = next(
+                (node for node in ast.walk(source_ast) if isinstance(node, ast.Lambda)),
+                None,
+            )
+
         if lambda_node is None:
             return None
         lambda_text = source_text[lambda_node.col_offset : lambda_node.end_col_offset]

{neuroglia_python-0.7.3 → neuroglia_python-0.7.5}/src/neuroglia/hosting/configuration/data_access_layer.py

@@ -23,15 +23,26 @@ class DataAccessLayer:
         """Represents a helper class used to configure an application's Write Model DAL
 
         Supports two configuration patterns:
-        1. Simplified: Pass options directly to constructor
+        1. Simplified: Pass database_name, consumer_group, and delete_mode to constructor
         2. Custom: Pass custom repository_setup function to configure()
 
         Examples:
-            # Simple configuration with default options
-            DataAccessLayer.WriteModel().configure(builder, ["domain.entities"])
-
-            # With custom delete mode
+            # Simple configuration with all required parameters
             from neuroglia.data.infrastructure.event_sourcing.abstractions import DeleteMode
+
+            DataAccessLayer.WriteModel(
+                database_name="myapp",
+                consumer_group="myapp_group",
+                delete_mode=DeleteMode.HARD
+            ).configure(builder, ["domain.entities"])
+
+            # Minimal configuration (uses default delete mode)
+            DataAccessLayer.WriteModel(
+                database_name="myapp",
+                consumer_group="myapp_group"
+            ).configure(builder, ["domain.entities"])
+
+            # Legacy: With EventSourcingRepositoryOptions (backwards compatible)
             from neuroglia.data.infrastructure.event_sourcing.event_sourcing_repository import (
                 EventSourcingRepositoryOptions
             )
@@ -49,13 +60,42 @@ class DataAccessLayer:
             )
         """
 
-        def __init__(self, options: Optional["EventSourcingRepositoryOptions"] = None):
+        def __init__(
+            self,
+            database_name: Optional[str] = None,
+            consumer_group: Optional[str] = None,
+            delete_mode: Optional["DeleteMode"] = None,
+            options: Optional["EventSourcingRepositoryOptions"] = None,
+        ):
             """Initialize WriteModel configuration
 
             Args:
-                options: Optional repository options (e.g., delete_mode).
-                        If not provided, default options will be used.
+                database_name: Database/stream prefix for event store (e.g., "myapp").
+                              Internally creates EventStoreOptions and calls ESEventStore.configure().
+                consumer_group: Consumer group name for event store subscriptions.
+                delete_mode: Optional deletion strategy (DISABLED, SOFT, HARD).
+                            If not provided, defaults to DISABLED.
+                options: Legacy parameter for EventSourcingRepositoryOptions (backwards compatible).
+                        If database_name is provided, this parameter is ignored.
+
+            Example:
+                ```python
+                # Simplified configuration (recommended)
+                DataAccessLayer.WriteModel(
+                    database_name="myapp",
+                    consumer_group="myapp_group",
+                    delete_mode=DeleteMode.HARD
+                ).configure(builder, ["domain.entities"])
+
+                # Legacy (still supported)
+                DataAccessLayer.WriteModel(
+                    options=EventSourcingRepositoryOptions(delete_mode=DeleteMode.HARD)
+                ).configure(builder, ["domain.entities"])
+                ```
             """
+            self._database_name = database_name
+            self._consumer_group = consumer_group
+            self._delete_mode = delete_mode
             self._options = options
 
         def configure(self, builder: ApplicationBuilderBase, modules: list[str], repository_setup: Optional[Callable[[ApplicationBuilderBase, type, type], None]] = None) -> ApplicationBuilderBase:
@@ -66,13 +106,14 @@ class DataAccessLayer:
                 modules (List[str]): a list containing the names of the modules to scan for aggregate root types
                 repository_setup (Optional[Callable[[ApplicationBuilderBase, Type, Type], None]]):
                     Optional custom function to setup repositories. If provided, takes precedence over options.
-                    If not provided, uses simplified configuration with options (if any).
+                    If not provided, uses simplified configuration with database_name/consumer_group or options.
 
             Returns:
                 ApplicationBuilderBase: The configured builder
 
             Raises:
                 ImportError: If EventSourcingRepository cannot be imported
+                ValueError: If database_name is provided without consumer_group
             """
             # If custom setup provided, use it (backwards compatible)
             if repository_setup is not None:
@@ -82,7 +123,26 @@ class DataAccessLayer:
                         repository_setup(builder, aggregate_type, key_type)
                 return builder
 
-            # Otherwise use simplified configuration with options
+            # If database_name provided, configure event store and use simplified configuration
+            if self._database_name is not None:
+                if self._consumer_group is None:
+                    raise ValueError("consumer_group is required when database_name is provided")
+
+                # Configure ESEventStore
+                from neuroglia.data.infrastructure.event_sourcing.abstractions import (
+                    EventStoreOptions,
+                )
+                from neuroglia.data.infrastructure.event_sourcing.event_store.event_store import (
+                    ESEventStore,
+                )
+
+                event_store_options = EventStoreOptions(
+                    database_name=self._database_name,
+                    consumer_group=self._consumer_group,
+                )
+                ESEventStore.configure(builder, event_store_options)
+
+            # Otherwise use simplified configuration with options or defaults
             return self._configure_with_options(builder, modules)
 
         def _configure_with_options(self, builder: ApplicationBuilderBase, modules: list[str]) -> ApplicationBuilderBase:
@@ -98,6 +158,7 @@ class DataAccessLayer:
             from neuroglia.data.infrastructure.abstractions import Repository
             from neuroglia.data.infrastructure.event_sourcing.abstractions import (
                 Aggregator,
+                DeleteMode,
                 EventStore,
             )
             from neuroglia.data.infrastructure.event_sourcing.event_sourcing_repository import (
@@ -107,6 +168,9 @@ class DataAccessLayer:
             from neuroglia.dependency_injection import ServiceProvider
             from neuroglia.mediation import Mediator
 
+            # Determine delete mode to use
+            delete_mode = self._delete_mode if self._delete_mode is not None else (self._options.delete_mode if self._options else DeleteMode.DISABLED)
+
             # Discover and configure each aggregate type
             for module in [ModuleLoader.load(module_name) for module_name in modules]:
                 for aggregate_type in TypeFinder.get_types(
@@ -115,13 +179,11 @@ class DataAccessLayer:
                 ):
                     key_type = str  # todo: reflect from DTO base type
 
-                    # Create type-specific options if global options provided
-                    typed_options = None
-                    if self._options:
-                        typed_options = EventSourcingRepositoryOptions[aggregate_type, key_type](  # type: ignore
-                            delete_mode=self._options.delete_mode,
-                            soft_delete_method_name=self._options.soft_delete_method_name,
-                        )
+                    # Create type-specific options
+                    typed_options = EventSourcingRepositoryOptions[aggregate_type, key_type](  # type: ignore
+                        delete_mode=delete_mode,
+                        soft_delete_method_name=self._options.soft_delete_method_name if self._options else "mark_as_deleted",
+                    )
 
                     # Create factory function with proper closure
                     def make_factory(et, kt, opts):