flowquery 1.0.18 → 1.0.21

package/flowquery-py/src/parsing/operations/create_relationship.py

@@ -2,20 +2,22 @@
 
 from typing import Any, Dict, List
 
-from .operation import Operation
+from ...graph.database import Database
+from ...graph.relationship import Relationship
 from ..ast_node import ASTNode
+from .operation import Operation
 
 
 class CreateRelationship(Operation):
     """Represents a CREATE operation for creating virtual relationships."""
 
-    def __init__(self, relationship, statement: ASTNode):
+    def __init__(self, relationship: Relationship, statement: ASTNode) -> None:
         super().__init__()
         self._relationship = relationship
         self._statement = statement
 
     @property
-    def relationship(self):
+    def relationship(self) -> Relationship:
         return self._relationship
 
     @property
@@ -25,7 +27,6 @@ class CreateRelationship(Operation):
     async def run(self) -> None:
         if self._relationship is None:
             raise ValueError("Relationship is null")
-        from ...graph.database import Database
         db = Database.get_instance()
         db.add_relationship(self._relationship, self._statement)
 

package/flowquery-py/src/parsing/operations/group_by.py

@@ -2,7 +2,7 @@
 
 from typing import Any, Dict, Generator, List, Optional
 
-from ..expressions.expression import Expression
+from ..ast_node import ASTNode
 from ..functions.aggregate_function import AggregateFunction
 from ..functions.reducer_element import ReducerElement
 from .projection import Projection
@@ -36,13 +36,13 @@ class GroupByNode:
 class GroupBy(Projection):
     """Implements grouping and aggregation for FlowQuery operations."""
 
-    def __init__(self, expressions: List[Expression]):
+    def __init__(self, expressions: List[ASTNode]) -> None:
         super().__init__(expressions)
         self._root = GroupByNode()
         self._current = self._root
-        self._mappers: Optional[List[Expression]] = None
+        self._mappers: Optional[List[Any]] = None
         self._reducers: Optional[List[AggregateFunction]] = None
-        self._where = None
+        self._where: Optional[ASTNode] = None
 
     async def run(self) -> None:
         self._reset_tree()
@@ -71,18 +71,19 @@ class GroupBy(Projection):
         if self._current.elements is None:
             self._current.elements = [reducer.element() for reducer in self.reducers]
         elements = self._current.elements
-        for i, reducer in enumerate(self.reducers):
-            reducer.reduce(elements[i])
+        if elements:
+            for i, reducer in enumerate(self.reducers):
+                reducer.reduce(elements[i])
 
     @property
-    def mappers(self) -> List[Expression]:
+    def mappers(self) -> List[Any]:
         if self._mappers is None:
             self._mappers = list(self._generate_mappers())
         return self._mappers
 
-    def _generate_mappers(self) -> Generator[Expression, None, None]:
+    def _generate_mappers(self) -> Generator[Any, None, None]:
         for expression, _ in self.expressions():
-            if expression.mappable():
+            if hasattr(expression, 'mappable') and expression.mappable():
                 yield expression
 
     @property
@@ -90,17 +91,18 @@ class GroupBy(Projection):
         if self._reducers is None:
             self._reducers = []
             for child in self.children:
-                self._reducers.extend(child.reducers())
+                if hasattr(child, 'reducers'):
+                    self._reducers.extend(child.reducers())
         return self._reducers
 
     def generate_results(
-        self, 
-        mapper_index: int = 0, 
+        self,
+        mapper_index: int = 0,
         node: Optional[GroupByNode] = None
     ) -> Generator[Dict[str, Any], None, None]:
         if node is None:
             node = self._root
-        
+
         if len(node.children) > 0:
             for child in node.children.values():
                 self.mappers[mapper_index].overridden = child.value
@@ -116,15 +118,15 @@ class GroupBy(Projection):
                 yield record
 
     @property
-    def where(self):
+    def where(self) -> Optional[ASTNode]:
         return self._where
 
     @where.setter
-    def where(self, where) -> None:
+    def where(self, where: Optional[ASTNode]) -> None:
         self._where = where
 
     @property
-    def where_condition(self) -> bool:
+    def where_condition(self) -> Any:
         if self._where is None:
             return True
         return self._where.value()

package/flowquery-py/src/parsing/operations/load.py

@@ -3,24 +3,31 @@
 import json
 from typing import Any, Dict, Optional
 
-from .operation import Operation
+import aiohttp
+
+from ..ast_node import ASTNode
+from ..components.headers import Headers
+from ..components.json import JSON as JSONComponent
+from ..components.post import Post
+from ..components.text import Text
 from ..functions.async_function import AsyncFunction
+from .operation import Operation
 
 
 class Load(Operation):
     """Represents a LOAD operation that fetches data from external sources."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self._value: Any = None
 
     @property
-    def type(self):
+    def type(self) -> ASTNode:
         """Gets the data type (JSON, CSV, or Text)."""
         return self.children[0]
 
     @property
-    def from_component(self):
+    def from_component(self) -> ASTNode:
         """Gets the From component which contains either a URL expression or an AsyncFunction."""
         return self.children[1]
 
@@ -36,19 +43,17 @@ class Load(Operation):
         return child if isinstance(child, AsyncFunction) else None
 
     @property
-    def from_(self) -> str:
+    def from_(self) -> Any:
         return self.children[1].value()
 
     @property
     def headers(self) -> Dict[str, str]:
-        from ..components.headers import Headers
         if self.child_count() > 2 and isinstance(self.children[2], Headers):
             return self.children[2].value() or {}
         return {}
 
     @property
-    def payload(self):
-        from ..components.post import Post
+    def payload(self) -> Optional[ASTNode]:
         post = None
         if self.child_count() > 2 and isinstance(self.children[2], Post):
             post = self.children[2]
@@ -86,26 +91,22 @@ class Load(Operation):
 
     async def _load_from_url(self) -> None:
         """Loads data from a URL source."""
-        import aiohttp
-        from ..components.json import JSON as JSONComponent
-        from ..components.text import Text
-        
         async with aiohttp.ClientSession() as session:
             options = self._options()
             method = options.pop("method")
             headers = options.pop("headers", {})
             body = options.pop("body", None)
-            
+
             # Set Accept-Encoding to support common compression formats
             # Note: brotli (br) is excluded due to API incompatibility between
             # aiohttp 3.13+ and the brotli package's Decompressor.decompress() method
             if "Accept-Encoding" not in headers:
                 headers["Accept-Encoding"] = "gzip, deflate"
-            
+
             async with session.request(
-                method, 
-                self.from_, 
-                headers=headers, 
+                method,
+                self.from_,
+                headers=headers,
                 data=body
             ) as response:
                 if isinstance(self.type, JSONComponent):
@@ -114,7 +115,7 @@ class Load(Operation):
                     data = await response.text()
                 else:
                     data = await response.text()
-                
+
                 if isinstance(data, list):
                     for item in data:
                         self._value = item
@@ -139,7 +140,8 @@ class Load(Operation):
         try:
             await self.load()
         except Exception as e:
-            source = self.async_function.name if self.is_async_function else self.from_
+            async_func = self.async_function
+            source = async_func.name if async_func else self.from_
             raise RuntimeError(f"Failed to load data from {source}. Error: {e}")
 
     def value(self) -> Any:

package/flowquery-py/src/parsing/operations/match.py

@@ -1,29 +1,30 @@
 """Represents a MATCH operation for graph pattern matching."""
 
-from typing import List
+from typing import List, Optional
 
+from ...graph.pattern import Pattern
+from ...graph.patterns import Patterns
 from .operation import Operation
 
 
 class Match(Operation):
     """Represents a MATCH operation for graph pattern matching."""
 
-    def __init__(self, patterns=None):
+    def __init__(self, patterns: Optional[List[Pattern]] = None) -> None:
         super().__init__()
-        from ...graph.patterns import Patterns
         self._patterns = Patterns(patterns or [])
 
     @property
-    def patterns(self):
+    def patterns(self) -> List[Pattern]:
         return self._patterns.patterns if self._patterns else []
 
     async def run(self) -> None:
         """Executes the match operation by chaining the patterns together."""
         await self._patterns.initialize()
-        
-        async def to_do_next():
+
+        async def to_do_next() -> None:
             if self.next:
                 await self.next.run()
-        
+
         self._patterns.to_do_next = to_do_next
         await self._patterns.traverse()

package/flowquery-py/src/parsing/operations/operation.py

@@ -8,12 +8,12 @@ from ..ast_node import ASTNode
 
 class Operation(ASTNode, ABC):
     """Base class for all FlowQuery operations.
-    
+
     Operations represent the main statements in FlowQuery (WITH, UNWIND, RETURN, LOAD, WHERE).
     They form a linked list structure and can be executed sequentially.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self._previous: Optional[Operation] = None
         self._next: Optional[Operation] = None
@@ -46,7 +46,7 @@ class Operation(ASTNode, ABC):
 
     async def run(self) -> None:
         """Executes this operation. Must be implemented by subclasses.
-        
+
         Raises:
             NotImplementedError: If not implemented by subclass
         """

package/flowquery-py/src/parsing/operations/projection.py

@@ -1,21 +1,21 @@
 """Base class for projection operations."""
 
-from typing import Generator, List, Tuple, Optional
+from typing import Any, Generator, List, Tuple
 
-from ..expressions.expression import Expression
+from ..ast_node import ASTNode
 from .operation import Operation
 
 
 class Projection(Operation):
     """Base class for operations that project expressions."""
 
-    def __init__(self, expressions: List[Expression]):
+    def __init__(self, expressions: List[ASTNode]):
         super().__init__()
         self.children = expressions
 
-    def expressions(self) -> Generator[Tuple[Expression, str], None, None]:
+    def expressions(self) -> Generator[Tuple[Any, str], None, None]:
         """Yields tuples of (expression, alias) for all child expressions."""
         for i, child in enumerate(self.children):
-            expression: Expression = child
-            alias = expression.alias or f"expr{i}"
+            expression = child
+            alias = getattr(expression, 'alias', None) or f"expr{i}"
             yield (expression, alias)

package/flowquery-py/src/parsing/operations/return_op.py

@@ -1,28 +1,32 @@
 """Represents a RETURN operation that produces the final query results."""
 
 import copy
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
+from ..ast_node import ASTNode
 from .projection import Projection
 
+if TYPE_CHECKING:
+    from .where import Where
+
 
 class Return(Projection):
     """Represents a RETURN operation that produces the final query results.
-    
+
     The RETURN operation evaluates expressions and collects them into result records.
     It can optionally have a WHERE clause to filter results.
-    
+
     Example:
         # RETURN x, y WHERE x > 0
     """
 
-    def __init__(self, expressions):
+    def __init__(self, expressions: List[ASTNode]) -> None:
         super().__init__(expressions)
         self._where: Optional['Where'] = None
         self._results: List[Dict[str, Any]] = []
 
     @property
-    def where(self) -> bool:
+    def where(self) -> Any:
         if self._where is None:
             return True
         return self._where.value()

package/flowquery-py/src/parsing/operations/unwind.py

@@ -2,6 +2,7 @@
 
 from typing import Any
 
+from ..ast_node import ASTNode
 from ..expressions.expression import Expression
 from .operation import Operation
 
@@ -15,11 +16,11 @@ class Unwind(Operation):
         self.add_child(expression)
 
     @property
-    def expression(self) -> Expression:
+    def expression(self) -> ASTNode:
         return self.children[0]
 
     @property
-    def as_(self) -> str:
+    def as_(self) -> Any:
         return self.children[1].value()
 
     async def run(self) -> None:

package/flowquery-py/src/parsing/operations/where.py

@@ -2,23 +2,24 @@
 
 from typing import Any
 
+from ..ast_node import ASTNode
 from ..expressions.expression import Expression
 from .operation import Operation
 
 
 class Where(Operation):
     """Represents a WHERE operation that filters data based on a condition.
-    
+
     The WHERE operation evaluates a boolean expression and only continues
     execution to the next operation if the condition is true.
-    
+
     Example:
         # RETURN x WHERE x > 0
     """
 
     def __init__(self, expression: Expression):
         """Creates a new WHERE operation with the given condition.
-        
+
         Args:
             expression: The boolean expression to evaluate
         """
@@ -26,13 +27,14 @@ class Where(Operation):
         self.add_child(expression)
 
     @property
-    def expression(self) -> Expression:
+    def expression(self) -> ASTNode:
         return self.children[0]
 
     async def run(self) -> None:
-        for pattern in self.expression.patterns():
-            await pattern.fetch_data()
-            await pattern.evaluate()
+        if hasattr(self.expression, 'patterns'):
+            for pattern in self.expression.patterns():
+                await pattern.fetch_data()
+                await pattern.evaluate()
         if self.expression.value():
             if self.next:
                 await self.next.run()

package/flowquery-py/src/parsing/operations/with_op.py

@@ -5,10 +5,10 @@ from .projection import Projection
 
 class With(Projection):
     """Represents a WITH operation that defines variables or intermediate results.
-    
+
     The WITH operation creates named expressions that can be referenced later in the query.
     It passes control to the next operation in the chain.
-    
+
     Example:
         # WITH x = 1, y = 2 RETURN x + y
     """