flowquery 1.0.18 → 1.0.21

package/flowquery-py/src/parsing/ast_node.py

@@ -1,28 +1,29 @@
 """Represents a node in the Abstract Syntax Tree (AST)."""
 
 from __future__ import annotations
-from typing import List, Any, Generator, Optional
+
+from typing import Any, Generator, List, Optional
 
 
 class ASTNode:
     """Represents a node in the Abstract Syntax Tree (AST).
-    
+
     The AST is a tree representation of the parsed FlowQuery statement structure.
     Each node can have children and maintains a reference to its parent.
-    
+
     Example:
         root = ASTNode()
         child = ASTNode()
         root.add_child(child)
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._parent: Optional[ASTNode] = None
         self.children: List[ASTNode] = []
 
     def add_child(self, child: ASTNode) -> None:
         """Adds a child node to this node and sets the child's parent reference.
-        
+
         Args:
             child: The child node to add
         """
@@ -31,10 +32,10 @@ class ASTNode:
 
     def first_child(self) -> ASTNode:
         """Returns the first child node.
-        
+
         Returns:
             The first child node
-            
+
         Raises:
             ValueError: If the node has no children
         """
@@ -44,10 +45,10 @@ class ASTNode:
 
     def last_child(self) -> ASTNode:
         """Returns the last child node.
-        
+
         Returns:
             The last child node
-            
+
         Raises:
             ValueError: If the node has no children
         """
@@ -57,7 +58,7 @@ class ASTNode:
 
     def get_children(self) -> List[ASTNode]:
         """Returns all child nodes.
-        
+
         Returns:
             Array of child nodes
         """
@@ -65,7 +66,7 @@ class ASTNode:
 
     def child_count(self) -> int:
         """Returns the number of child nodes.
-        
+
         Returns:
             The count of children
         """
@@ -73,7 +74,7 @@ class ASTNode:
 
     def value(self) -> Any:
         """Returns the value of this node. Override in subclasses to provide specific values.
-        
+
         Returns:
             The node's value, or None if not applicable
         """
@@ -81,7 +82,7 @@ class ASTNode:
 
     def is_operator(self) -> bool:
         """Checks if this node represents an operator.
-        
+
         Returns:
             True if this is an operator node, False otherwise
         """
@@ -89,7 +90,7 @@ class ASTNode:
 
     def is_operand(self) -> bool:
         """Checks if this node represents an operand (the opposite of an operator).
-        
+
         Returns:
             True if this is an operand node, False otherwise
         """
@@ -98,7 +99,7 @@ class ASTNode:
     @property
     def precedence(self) -> int:
         """Gets the operator precedence for this node. Higher values indicate higher precedence.
-        
+
         Returns:
             The precedence value (0 for non-operators)
         """
@@ -107,7 +108,7 @@ class ASTNode:
     @property
     def left_associative(self) -> bool:
         """Indicates whether this operator is left-associative.
-        
+
         Returns:
             True if left-associative, False otherwise
         """
@@ -115,7 +116,7 @@ class ASTNode:
 
     def print(self) -> str:
         """Prints a string representation of the AST tree starting from this node.
-        
+
         Returns:
             A formatted string showing the tree structure
         """
@@ -123,10 +124,10 @@ class ASTNode:
 
     def _print(self, indent: int) -> Generator[str, None, None]:
         """Generator function for recursively printing the tree structure.
-        
+
         Args:
             indent: The current indentation level
-            
+
         Yields:
             Lines representing each node in the tree
         """
@@ -139,7 +140,7 @@ class ASTNode:
 
     def __str__(self) -> str:
         """Returns a string representation of this node. Override in subclasses for custom formatting.
-        
+
         Returns:
             The string representation
         """

package/flowquery-py/src/parsing/base_parser.py

@@ -8,7 +8,7 @@ from ..tokenization.tokenizer import Tokenizer
 
 class BaseParser:
     """Base class for parsers providing common token manipulation functionality.
-    
+
     This class handles tokenization and provides utility methods for navigating
     through tokens, peeking ahead, and checking token sequences.
     """
@@ -19,7 +19,7 @@ class BaseParser:
 
     def tokenize(self, statement: str) -> None:
         """Tokenizes a statement and initializes the token array.
-        
+
         Args:
             statement: The input statement to tokenize
         """
@@ -32,7 +32,7 @@ class BaseParser:
 
     def peek(self) -> Optional[Token]:
         """Peeks at the next token without advancing the current position.
-        
+
         Returns:
             The next token, or None if at the end of the token stream
         """
@@ -42,11 +42,11 @@ class BaseParser:
 
     def ahead(self, tokens: List[Token], skip_whitespace_and_comments: bool = True) -> bool:
         """Checks if a sequence of tokens appears ahead in the token stream.
-        
+
         Args:
             tokens: The sequence of tokens to look for
             skip_whitespace_and_comments: Whether to skip whitespace and comments when matching
-            
+
         Returns:
             True if the token sequence is found ahead, False otherwise
         """
@@ -64,7 +64,7 @@ class BaseParser:
     @property
     def token(self) -> Token:
         """Gets the current token.
-        
+
         Returns:
             The current token, or EOF if at the end
         """
@@ -75,7 +75,7 @@ class BaseParser:
     @property
     def previous_token(self) -> Token:
         """Gets the previous token.
-        
+
         Returns:
             The previous token, or EOF if at the beginning
         """

package/flowquery-py/src/parsing/components/__init__.py

@@ -1,12 +1,12 @@
 """Components module for FlowQuery parsing."""
 
 from .csv import CSV
-from .json import JSON
-from .text import Text
 from .from_ import From
 from .headers import Headers
-from .post import Post
+from .json import JSON
 from .null import Null
+from .post import Post
+from .text import Text
 
 __all__ = [
     "CSV",

package/flowquery-py/src/parsing/components/from_.py

@@ -1,10 +1,12 @@
 """From component node."""
 
+from typing import Any
+
 from ..ast_node import ASTNode
 
 
 class From(ASTNode):
     """Represents a FROM clause in LOAD operations."""
 
-    def value(self) -> str:
+    def value(self) -> Any:
         return self.children[0].value()

package/flowquery-py/src/parsing/components/headers.py

@@ -1,6 +1,6 @@
 """Headers component node."""
 
-from typing import Dict
+from typing import Any, Dict
 
 from ..ast_node import ASTNode
 
@@ -8,5 +8,5 @@ from ..ast_node import ASTNode
 class Headers(ASTNode):
     """Represents a HEADERS clause in LOAD operations."""
 
-    def value(self) -> Dict:
+    def value(self) -> Dict[str, Any]:
         return self.first_child().value() or {}

package/flowquery-py/src/parsing/components/null.py

@@ -5,6 +5,6 @@ from ..ast_node import ASTNode
 
 class Null(ASTNode):
     """Represents a NULL value in the AST."""
-    
-    def value(self):
+
+    def value(self) -> None:
         return None

package/flowquery-py/src/parsing/context.py

@@ -7,22 +7,22 @@ from .ast_node import ASTNode
 
 class Context:
     """Maintains a stack of AST nodes to track parsing context.
-    
+
     Used during parsing to maintain the current context and check for specific node types
     in the parsing hierarchy, which helps with context-sensitive parsing decisions.
-    
+
     Example:
         context = Context()
         context.push(node)
         has_return = context.contains_type(Return)
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._nodes: List[ASTNode] = []
 
     def push(self, node: ASTNode) -> None:
         """Pushes a node onto the context stack.
-        
+
         Args:
             node: The AST node to push
         """
@@ -30,7 +30,7 @@ class Context:
 
     def pop(self) -> Optional[ASTNode]:
         """Pops the top node from the context stack.
-        
+
         Returns:
             The popped node, or None if the stack is empty
         """
@@ -40,10 +40,10 @@ class Context:
 
     def contains_type(self, type_: Type[ASTNode]) -> bool:
         """Checks if the nodes stack contains a node of the specified type.
-        
+
         Args:
             type_: The class of the node type to search for
-            
+
         Returns:
             True if a node of the specified type is found in the stack, False otherwise
         """

package/flowquery-py/src/parsing/data_structures/associative_array.py

@@ -1,6 +1,6 @@
 """Represents an associative array (object/dictionary) in the AST."""
 
-from typing import Any, Dict
+from typing import Any, Dict, Generator
 
 from ..ast_node import ASTNode
 from .key_value_pair import KeyValuePair
@@ -8,9 +8,9 @@ from .key_value_pair import KeyValuePair
 
 class AssociativeArray(ASTNode):
     """Represents an associative array (object/dictionary) in the AST.
-    
+
     Associative arrays map string keys to values, similar to JSON objects.
-    
+
     Example:
         # For { name: "Alice", age: 30 }
         obj = AssociativeArray()
@@ -20,7 +20,7 @@ class AssociativeArray(ASTNode):
 
     def add_key_value(self, key_value_pair: KeyValuePair) -> None:
         """Adds a key-value pair to the associative array.
-        
+
         Args:
             key_value_pair: The key-value pair to add
         """
@@ -29,10 +29,10 @@ class AssociativeArray(ASTNode):
     def __str__(self) -> str:
         return 'AssociativeArray'
 
-    def _value(self):
+    def _value(self) -> Generator[Dict[str, Any], None, None]:
         for child in self.children:
-            key_value = child
-            yield {key_value.key: key_value._value}
+            if isinstance(child, KeyValuePair):
+                yield {child.key: child._value}
 
     def value(self) -> Dict[str, Any]:
         result = {}

package/flowquery-py/src/parsing/data_structures/json_array.py

@@ -7,9 +7,9 @@ from ..ast_node import ASTNode
 
 class JSONArray(ASTNode):
     """Represents a JSON array in the AST.
-    
+
     JSON arrays are ordered collections of values.
-    
+
     Example:
         # For [1, 2, 3]
         arr = JSONArray()
@@ -20,7 +20,7 @@ class JSONArray(ASTNode):
 
     def add_value(self, value: ASTNode) -> None:
         """Adds a value to the array.
-        
+
         Args:
             value: The AST node representing the value to add
         """

package/flowquery-py/src/parsing/data_structures/key_value_pair.py

@@ -8,16 +8,16 @@ from ..expressions.string import String
 
 class KeyValuePair(ASTNode):
     """Represents a key-value pair in an associative array.
-    
+
     Used to build object literals in FlowQuery.
-    
+
     Example:
         kvp = KeyValuePair("name", String("Alice"))
     """
 
     def __init__(self, key: str, value: ASTNode):
         """Creates a new key-value pair.
-        
+
         Args:
             key: The key string
             value: The AST node representing the value
@@ -27,7 +27,7 @@ class KeyValuePair(ASTNode):
         self.add_child(value)
 
     @property
-    def key(self) -> str:
+    def key(self) -> Any:
         return self.children[0].value()
 
     @property

package/flowquery-py/src/parsing/data_structures/lookup.py

@@ -7,9 +7,9 @@ from ..ast_node import ASTNode
 
 class Lookup(ASTNode):
     """Represents a lookup operation (array/object indexing) in the AST.
-    
+
     Lookups access elements from arrays or properties from objects using an index or key.
-    
+
     Example:
         # For array[0] or obj.property or obj["key"]
         lookup = Lookup()

package/flowquery-py/src/parsing/data_structures/range_lookup.py

@@ -1,6 +1,6 @@
 """Represents a range lookup operation in the AST."""
 
-from typing import Any, List
+from typing import Any
 
 from ..ast_node import ASTNode
 
@@ -35,7 +35,7 @@ class RangeLookup(ASTNode):
     def is_operand(self) -> bool:
         return True
 
-    def value(self) -> List[Any]:
+    def value(self) -> Any:
         array = self.variable.value()
         from_val = self.from_.value() or 0
         to_val = self.to.value() or len(array)

package/flowquery-py/src/parsing/expressions/__init__.py

@@ -1,32 +1,32 @@
 """Expressions module for FlowQuery parsing."""
 
-from .expression import Expression
 from .boolean import Boolean
-from .number import Number
-from .string import String
-from .identifier import Identifier
-from .reference import Reference
-from .f_string import FString
+from .expression import Expression
 from .expression_map import ExpressionMap
+from .f_string import FString
+from .identifier import Identifier
+from .number import Number
 from .operator import (
-    Operator,
     Add,
-    Subtract,
-    Multiply,
+    And,
     Divide,
-    Modulo,
-    Power,
     Equals,
-    NotEquals,
     GreaterThan,
-    LessThan,
     GreaterThanOrEqual,
+    Is,
+    LessThan,
     LessThanOrEqual,
-    And,
-    Or,
+    Modulo,
+    Multiply,
     Not,
-    Is,
+    NotEquals,
+    Operator,
+    Or,
+    Power,
+    Subtract,
 )
+from .reference import Reference
+from .string import String
 
 __all__ = [
     "Expression",

package/flowquery-py/src/parsing/expressions/expression.py

@@ -1,21 +1,24 @@
 """Represents an expression in the FlowQuery AST."""
 
-from typing import Any, List, Optional, Generator, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Generator, List, Optional
 
 from ..ast_node import ASTNode
+from ..functions.aggregate_function import AggregateFunction
+from .reference import Reference
 
 if TYPE_CHECKING:
-    from ..functions.aggregate_function import AggregateFunction
     from ...graph.pattern_expression import PatternExpression
 
 
 class Expression(ASTNode):
     """Represents an expression in the FlowQuery AST.
-    
+
     Expressions are built using the Shunting Yard algorithm to handle operator
     precedence and associativity. They can contain operands (numbers, strings, identifiers)
     and operators (arithmetic, logical, comparison).
-    
+
     Example:
         expr = Expression()
         expr.add_node(number_node)
@@ -24,7 +27,7 @@ class Expression(ASTNode):
         expr.finish()
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self._operators: List[ASTNode] = []
         self._output: List[ASTNode] = []
@@ -35,9 +38,9 @@ class Expression(ASTNode):
 
     def add_node(self, node: ASTNode) -> None:
         """Adds a node (operand or operator) to the expression.
-        
+
         Uses the Shunting Yard algorithm to maintain correct operator precedence.
-        
+
         Args:
             node: The AST node to add (operand or operator)
         """
@@ -58,7 +61,7 @@ class Expression(ASTNode):
 
     def finish(self) -> None:
         """Finalizes the expression by converting it to a tree structure.
-        
+
         Should be called after all nodes have been added.
         """
         while self._operators:
@@ -91,9 +94,9 @@ class Expression(ASTNode):
 
     @property
     def alias(self) -> Optional[str]:
-        from .reference import Reference
-        if isinstance(self.first_child(), Reference) and self._alias is None:
-            return self.first_child().identifier
+        first = self.first_child()
+        if isinstance(first, Reference) and self._alias is None:
+            return first.identifier
         return self._alias
 
     @alias.setter
@@ -106,14 +109,14 @@ class Expression(ASTNode):
         return "Expression"
 
     def reducers(self) -> List['AggregateFunction']:
+        from ..functions.aggregate_function import AggregateFunction
         if self._reducers is None:
-            from ..functions.aggregate_function import AggregateFunction
             self._reducers = list(self._extract(self, AggregateFunction))
         return self._reducers
 
     def patterns(self) -> List['PatternExpression']:
+        from ...graph.pattern_expression import PatternExpression
         if self._patterns is None:
-            from ...graph.pattern_expression import PatternExpression
             self._patterns = list(self._extract(self, PatternExpression))
         return self._patterns
 

package/flowquery-py/src/parsing/expressions/expression_map.py

@@ -1,26 +1,26 @@
 """Expression map for managing named expressions."""
 
-from typing import Optional, List, TYPE_CHECKING
+from __future__ import annotations
 
-if TYPE_CHECKING:
-    from .expression import Expression
+from typing import Any, List, Optional
 
 
 class ExpressionMap:
     """Maps expression aliases to their corresponding Expression objects."""
 
-    def __init__(self):
-        self._map: dict[str, Expression] = {}
+    def __init__(self) -> None:
+        self._map: dict[str, Any] = {}
 
-    def get(self, alias: str) -> Optional['Expression']:
+    def get(self, alias: str) -> Optional[Any]:
         return self._map.get(alias)
 
     def has(self, alias: str) -> bool:
         return alias in self._map
 
-    def set_map(self, expressions: List['Expression']) -> None:
+    def set_map(self, expressions: List[Any]) -> None:
         self._map.clear()
         for expr in expressions:
-            if expr.alias is None:
+            alias = getattr(expr, 'alias', None)
+            if alias is None:
                 continue
-            self._map[expr.alias] = expr
+            self._map[alias] = expr

package/flowquery-py/src/parsing/expressions/f_string.py

@@ -5,15 +5,15 @@ from typing import TYPE_CHECKING
 from ..ast_node import ASTNode
 
 if TYPE_CHECKING:
-    from .expression import Expression
+    pass
 
 
 class FString(ASTNode):
     """Represents a formatted string (f-string) in the AST.
-    
+
     F-strings allow embedding expressions within string literals.
     Child nodes represent the parts of the f-string (literal strings and expressions).
-    
+
     Example:
         # For f"Hello {name}!"
         fstr = FString()

package/flowquery-py/src/parsing/expressions/identifier.py

@@ -1,14 +1,15 @@
 """Represents an identifier in the AST."""
 
-from .string import String
 from typing import Any
 
+from .string import String
+
 
 class Identifier(String):
     """Represents an identifier in the AST.
-    
+
     Identifiers are used for variable names, property names, and similar constructs.
-    
+
     Example:
         id = Identifier("myVariable")
     """

package/flowquery-py/src/parsing/expressions/number.py

@@ -5,9 +5,9 @@ from ..ast_node import ASTNode
 
 class Number(ASTNode):
     """Represents a numeric literal in the AST.
-    
+
     Parses string representations of numbers into integer or float values.
-    
+
     Example:
         num = Number("42")
         print(num.value())  # 42
@@ -15,7 +15,7 @@ class Number(ASTNode):
 
     def __init__(self, value: str):
         """Creates a new Number node by parsing the string value.
-        
+
         Args:
             value: The string representation of the number
         """