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

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

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

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

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

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

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

@@ -33,7 +33,7 @@ See Also:
 
 import ast
 from ast import NodeVisitor, expr
-from typing import Any, Generic, List, Optional
+from typing import TYPE_CHECKING, Any, Generic, List, Optional
 
 import pymongo
 from motor.motor_asyncio import AsyncIOMotorCollection, AsyncIOMotorCursor
@@ -43,6 +43,9 @@ from neuroglia.expressions.javascript_expression_translator import (
     JavaScriptExpressionTranslator,
 )
 
+if TYPE_CHECKING:
+    from neuroglia.serialization import JsonSerializer
+
 
 class MotorQuery(Generic[T], Queryable[T]):
     """
@@ -71,6 +74,62 @@ class MotorQuery(Generic[T], Queryable[T]):
         """
         super().__init__(query_provider, expression)
 
+    async def to_list_async(self) -> list[T]:
+        """
+        Asynchronously execute the query and return results as a list.
+
+        This is the async equivalent of to_list() for Motor queries.
+
+        Returns:
+            List of entities matching the query
+
+        Example:
+            ```python
+            products = await repo.query_async() \\
+                .where(lambda p: p.price > 10) \\
+                .order_by(lambda p: p.name) \\
+                .to_list_async()
+            ```
+        """
+        # Get the provider and ensure it's a MotorQueryProvider
+        provider = self.provider
+        if not isinstance(provider, MotorQueryProvider):
+            raise TypeError("MotorQuery requires a MotorQueryProvider")
+
+        # Execute the query asynchronously
+        return await provider.execute_async(self.expression, List)
+
+    async def first_or_default_async(self, predicate=None) -> Optional[T]:
+        """
+        Asynchronously get the first element matching the predicate, or None.
+
+        Args:
+            predicate: Optional filter predicate
+
+        Returns:
+            First matching entity or None
+
+        Example:
+            ```python
+            product = await repo.query_async() \\
+                .where(lambda p: p.id == "prod123") \\
+                .first_or_default_async()
+            ```
+        """
+        # Get the provider and ensure it's a MotorQueryProvider
+        provider = self.provider
+        if not isinstance(provider, MotorQueryProvider):
+            raise TypeError("MotorQuery requires a MotorQueryProvider")
+
+        # If predicate provided, apply it as a where clause
+        query = self
+        if predicate is not None:
+            query = self.where(predicate)
+
+        # Execute and get list, then return first or None
+        results = await provider.execute_async(query.expression, List)
+        return results[0] if results else None
+
 
 class MotorQueryBuilder(NodeVisitor):
     """
@@ -228,25 +287,28 @@ class MotorQueryProvider(QueryProvider):
     Attributes:
         _collection: Motor async collection to query
         _entity_type: Type of entities in the collection
+        _serializer: JSON serializer for entity conversion
 
     Example:
         ```python
-        provider = MotorQueryProvider(motor_collection, Product)
+        provider = MotorQueryProvider(motor_collection, Product, serializer)
         query = provider.create_query(Product, expression)
         results = await provider.execute_async(expression, List[Product])
         ```
     """
 
-    def __init__(self, collection: AsyncIOMotorCollection, entity_type: type):
+    def __init__(self, collection: AsyncIOMotorCollection, entity_type: type, serializer: "JsonSerializer"):
         """
         Initialize the Motor query provider.
 
         Args:
             collection: Motor async collection
             entity_type: Type of entities being queried
+            serializer: JSON serializer for entity conversion
         """
         self._collection = collection
         self._entity_type = entity_type
+        self._serializer = serializer
 
     def create_query(self, element_type: type, expression: expr) -> Queryable:
         """
@@ -308,9 +370,29 @@ class MotorQueryProvider(QueryProvider):
             is_list_type = query_type.__origin__ in (list, List)
 
         if is_list_type:
-            # Return list of documents
-            return [doc async for doc in cursor]
+            # Return list of deserialized entities
+            documents = [doc async for doc in cursor]
+            return [self._deserialize_entity(doc) for doc in documents]
         else:
-            # Return single document
+            # Return single deserialized entity
             results = await cursor.to_list(length=1)
-            return results[0] if results else None
+            return self._deserialize_entity(results[0]) if results else None
+
+    def _deserialize_entity(self, doc: dict) -> Any:
+        """
+        Deserialize a MongoDB document to an entity instance.
+
+        Args:
+            doc: MongoDB document dictionary
+
+        Returns:
+            Deserialized entity instance
+        """
+        # Remove MongoDB's _id field
+        doc.pop("_id", None)
+
+        # Serialize dict back to JSON for deserialization
+        json_str = self._serializer.serialize_to_text(doc)
+
+        # Deserialize using the entity type
+        return self._serializer.deserialize_from_text(json_str, self._entity_type)

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

@@ -552,7 +552,7 @@ class MotorRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
         if entity_type is None:
             raise TypeError("Cannot create query: entity type not set. Pass entity_type to constructor.")
 
-        return MotorQuery[TEntity](MotorQueryProvider(self.collection, entity_type))
+        return MotorQuery[TEntity](MotorQueryProvider(self.collection, entity_type, self._serializer))
 
     async def get_all_async(self) -> list[TEntity]:
         """

{neuroglia_python-0.7.2 → 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]