flowquery 1.0.46 → 1.0.48

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

@@ -1,84 +0,0 @@
-"""Base class for parsers providing common token manipulation functionality."""
-
-from typing import List, Optional
-
-from ..tokenization.token import Token
-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.
-    """
-
-    def __init__(self, tokens: Optional[List[Token]] = None):
-        self._tokens: List[Token] = tokens or []
-        self._token_index: int = 0
-
-    def tokenize(self, statement: str) -> None:
-        """Tokenizes a statement and initializes the token array.
-
-        Args:
-            statement: The input statement to tokenize
-        """
-        self._tokens = Tokenizer(statement).tokenize()
-        self._token_index = 0
-
-    def set_next_token(self) -> None:
-        """Advances to the next token in the sequence."""
-        self._token_index += 1
-
-    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
-        """
-        if self._token_index + 1 >= len(self._tokens):
-            return None
-        return self._tokens[self._token_index + 1]
-
-    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
-        """
-        j = 0
-        for i in range(self._token_index, len(self._tokens)):
-            if skip_whitespace_and_comments and self._tokens[i].is_whitespace_or_comment():
-                continue
-            if not self._tokens[i].equals(tokens[j]):
-                return False
-            j += 1
-            if j == len(tokens):
-                break
-        return j == len(tokens)
-
-    @property
-    def token(self) -> Token:
-        """Gets the current token.
-
-        Returns:
-            The current token, or EOF if at the end
-        """
-        if self._token_index >= len(self._tokens):
-            return Token.EOF()
-        return self._tokens[self._token_index]
-
-    @property
-    def previous_token(self) -> Token:
-        """Gets the previous token.
-
-        Returns:
-            The previous token, or EOF if at the beginning
-        """
-        if self._token_index - 1 < 0:
-            return Token.EOF()
-        return self._tokens[self._token_index - 1]

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

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

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

@@ -1,8 +0,0 @@
-"""CSV component node."""
-
-from ..ast_node import ASTNode
-
-
-class CSV(ASTNode):
-    """Represents a CSV data type marker in LOAD operations."""
-    pass

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

@@ -1,12 +0,0 @@
-"""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) -> Any:
-        return self.children[0].value()

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

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

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

@@ -1,8 +0,0 @@
-"""JSON component node."""
-
-from ..ast_node import ASTNode
-
-
-class JSON(ASTNode):
-    """Represents a JSON data type marker in LOAD operations."""
-    pass

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

@@ -1,10 +0,0 @@
-"""Null component node."""
-
-from ..ast_node import ASTNode
-
-
-class Null(ASTNode):
-    """Represents a NULL value in the AST."""
-
-    def value(self) -> None:
-        return None

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

@@ -1,8 +0,0 @@
-"""Post component node."""
-
-from ..ast_node import ASTNode
-
-
-class Post(ASTNode):
-    """Represents a POST clause in LOAD operations."""
-    pass

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

@@ -1,8 +0,0 @@
-"""Text component node."""
-
-from ..ast_node import ASTNode
-
-
-class Text(ASTNode):
-    """Represents a Text data type marker in LOAD operations."""
-    pass

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

@@ -1,50 +0,0 @@
-"""Maintains a stack of AST nodes to track parsing context."""
-
-from typing import List, Optional, Type
-
-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) -> 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
-        """
-        self._nodes.append(node)
-
-    def pop(self) -> Optional[ASTNode]:
-        """Pops the top node from the context stack.
-
-        Returns:
-            The popped node, or None if the stack is empty
-        """
-        if len(self._nodes) == 0:
-            return None
-        return self._nodes.pop()
-
-    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
-        """
-        return any(isinstance(v, type_) for v in self._nodes)

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

@@ -1,15 +0,0 @@
-"""Data structures module for FlowQuery parsing."""
-
-from .associative_array import AssociativeArray
-from .json_array import JSONArray
-from .key_value_pair import KeyValuePair
-from .lookup import Lookup
-from .range_lookup import RangeLookup
-
-__all__ = [
-    "AssociativeArray",
-    "JSONArray",
-    "KeyValuePair",
-    "Lookup",
-    "RangeLookup",
-]

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

@@ -1,41 +0,0 @@
-"""Represents an associative array (object/dictionary) in the AST."""
-
-from typing import Any, Dict, Generator
-
-from ..ast_node import ASTNode
-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()
-        obj.add_key_value(KeyValuePair("name", name_expr))
-        obj.add_key_value(KeyValuePair("age", age_expr))
-    """
-
-    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
-        """
-        self.add_child(key_value_pair)
-
-    def __str__(self) -> str:
-        return 'AssociativeArray'
-
-    def _value(self) -> Generator[Dict[str, Any], None, None]:
-        for child in self.children:
-            if isinstance(child, KeyValuePair):
-                yield {child.key: child._value}
-
-    def value(self) -> Dict[str, Any]:
-        result = {}
-        for item in self._value():
-            result.update(item)
-        return result

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

@@ -1,30 +0,0 @@
-"""Represents a JSON array in the AST."""
-
-from typing import Any, List
-
-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()
-        arr.add_value(Number("1"))
-        arr.add_value(Number("2"))
-        arr.add_value(Number("3"))
-    """
-
-    def add_value(self, value: ASTNode) -> None:
-        """Adds a value to the array.
-
-        Args:
-            value: The AST node representing the value to add
-        """
-        self.add_child(value)
-
-    def value(self) -> List[Any]:
-        return [child.value() for child in self.children]

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

@@ -1,38 +0,0 @@
-"""Represents a key-value pair in an associative array."""
-
-from typing import Any
-
-from ..ast_node import ASTNode
-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
-        """
-        super().__init__()
-        self.add_child(String(key))
-        self.add_child(value)
-
-    @property
-    def key(self) -> Any:
-        return self.children[0].value()
-
-    @property
-    def _value(self) -> Any:
-        return self.children[1].value()
-
-    def __str__(self) -> str:
-        return "KeyValuePair"

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

@@ -1,51 +0,0 @@
-"""Represents a lookup operation (array/object indexing) in the AST."""
-
-from typing import Any
-
-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()
-        lookup.variable = array_or_obj_node
-        lookup.index = index_node
-    """
-
-    @property
-    def index(self) -> ASTNode:
-        return self.children[0]
-
-    @index.setter
-    def index(self, index: ASTNode) -> None:
-        self.add_child(index)
-
-    @property
-    def variable(self) -> ASTNode:
-        return self.children[1]
-
-    @variable.setter
-    def variable(self, variable: ASTNode) -> None:
-        self.add_child(variable)
-
-    def is_operand(self) -> bool:
-        return True
-
-    def value(self) -> Any:
-        obj = self.variable.value()
-        if obj is None:
-            return None
-        key = self.index.value()
-        # Try dict-like access first, then fall back to attribute access for objects
-        try:
-            return obj[key]
-        except (TypeError, KeyError):
-            # For objects with attributes (like dataclasses), use getattr
-            if hasattr(obj, key):
-                return getattr(obj, key)
-            raise

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

@@ -1,42 +0,0 @@
-"""Represents a range lookup operation in the AST."""
-
-from typing import Any
-
-from ..ast_node import ASTNode
-
-
-class RangeLookup(ASTNode):
-    """Represents a range lookup (array slicing) operation in the AST."""
-
-    @property
-    def from_(self) -> ASTNode:
-        return self.children[0]
-
-    @from_.setter
-    def from_(self, from_: ASTNode) -> None:
-        self.add_child(from_)
-
-    @property
-    def to(self) -> ASTNode:
-        return self.children[1]
-
-    @to.setter
-    def to(self, to: ASTNode) -> None:
-        self.add_child(to)
-
-    @property
-    def variable(self) -> ASTNode:
-        return self.children[2]
-
-    @variable.setter
-    def variable(self, variable: ASTNode) -> None:
-        self.add_child(variable)
-
-    def is_operand(self) -> bool:
-        return True
-
-    def value(self) -> Any:
-        array = self.variable.value()
-        from_val = self.from_.value() or 0
-        to_val = self.to.value() or len(array)
-        return array[from_val:to_val]

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

@@ -1,61 +0,0 @@
-"""Expressions module for FlowQuery parsing."""
-
-from .boolean import Boolean
-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 (
-    Add,
-    And,
-    Divide,
-    Equals,
-    GreaterThan,
-    GreaterThanOrEqual,
-    In,
-    Is,
-    LessThan,
-    LessThanOrEqual,
-    Modulo,
-    Multiply,
-    Not,
-    NotEquals,
-    NotIn,
-    Operator,
-    Or,
-    Power,
-    Subtract,
-)
-from .reference import Reference
-from .string import String
-
-__all__ = [
-    "Expression",
-    "Boolean",
-    "Number",
-    "String",
-    "Identifier",
-    "Reference",
-    "FString",
-    "ExpressionMap",
-    "Operator",
-    "Add",
-    "Subtract",
-    "Multiply",
-    "Divide",
-    "Modulo",
-    "Power",
-    "Equals",
-    "NotEquals",
-    "GreaterThan",
-    "LessThan",
-    "GreaterThanOrEqual",
-    "LessThanOrEqual",
-    "And",
-    "Or",
-    "Not",
-    "Is",
-    "In",
-    "NotIn",
-]

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

@@ -1,20 +0,0 @@
-"""Represents a boolean literal in the AST."""
-
-from ..ast_node import ASTNode
-
-
-class Boolean(ASTNode):
-    """Represents a boolean literal in the AST."""
-
-    def __init__(self, value: str):
-        super().__init__()
-        _value = value.upper()
-        if _value == "TRUE":
-            self._value = True
-        elif _value == "FALSE":
-            self._value = False
-        else:
-            raise ValueError(f"Invalid boolean value: {value}")
-
-    def value(self) -> bool:
-        return self._value

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

@@ -1,141 +0,0 @@
-"""Represents an expression in the FlowQuery AST."""
-
-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 ...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)
-        expr.add_node(plus_operator)
-        expr.add_node(another_number_node)
-        expr.finish()
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._operators: List[ASTNode] = []
-        self._output: List[ASTNode] = []
-        self._alias: Optional[str] = None
-        self._overridden: Any = None
-        self._reducers: Optional[List['AggregateFunction']] = None
-        self._patterns: Optional[List['PatternExpression']] = None
-
-    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)
-        """
-        # Implements the Shunting Yard algorithm
-        if node.is_operand():
-            self._output.append(node)
-        elif node.is_operator():
-            operator1 = node
-            while len(self._operators) > 0:
-                operator2 = self._operators[-1]
-                if (operator2.precedence > operator1.precedence or
-                    (operator2.precedence == operator1.precedence and operator1.left_associative)):
-                    self._output.append(operator2)
-                    self._operators.pop()
-                else:
-                    break
-            self._operators.append(operator1)
-
-    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:
-            self._output.append(self._operators.pop())
-        self.add_child(self._to_tree())
-
-    def _to_tree(self) -> ASTNode:
-        if not self._output:
-            return ASTNode()
-        node = self._output.pop()
-        if node.is_operator():
-            rhs = self._to_tree()
-            lhs = self._to_tree()
-            node.add_child(lhs)
-            node.add_child(rhs)
-        return node
-
-    def nodes_added(self) -> bool:
-        return len(self._operators) > 0 or len(self._output) > 0
-
-    def value(self) -> Any:
-        if self._overridden is not None:
-            return self._overridden
-        if self.child_count() != 1:
-            raise ValueError("Expected one child")
-        return self.children[0].value()
-
-    def set_alias(self, alias: str) -> None:
-        self._alias = alias
-
-    @property
-    def alias(self) -> Optional[str]:
-        first = self.first_child()
-        if isinstance(first, Reference) and self._alias is None:
-            return first.identifier
-        return self._alias
-
-    @alias.setter
-    def alias(self, value: str) -> None:
-        self._alias = value
-
-    def __str__(self) -> str:
-        if self._alias is not None:
-            return f"Expression ({self._alias})"
-        return "Expression"
-
-    def reducers(self) -> List['AggregateFunction']:
-        from ..functions.aggregate_function import AggregateFunction
-        if self._reducers is None:
-            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:
-            self._patterns = list(self._extract(self, PatternExpression))
-        return self._patterns
-
-    def _extract(self, node: ASTNode, of_type: type) -> Generator[Any, None, None]:
-        if isinstance(node, of_type):
-            yield node
-        for child in node.get_children():
-            yield from self._extract(child, of_type)
-
-    def mappable(self) -> bool:
-        return len(self.reducers()) == 0
-
-    def has_reducers(self) -> bool:
-        return len(self.reducers()) > 0
-
-    @property
-    def overridden(self) -> Any:
-        return self._overridden
-
-    @overridden.setter
-    def overridden(self, value: Any) -> None:
-        self._overridden = value