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

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

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

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

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

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

{neuroglia_python-0.7.3 → neuroglia_python-0.7.4}/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
@@ -146,7 +145,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 +161,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 +178,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 +243,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.4}/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):