flowquery 1.0.46 → 1.0.48

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

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

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

@@ -1,27 +0,0 @@
-"""Represents a formatted string (f-string) in the AST."""
-
-from typing import TYPE_CHECKING
-
-from ..ast_node import ASTNode
-
-if TYPE_CHECKING:
-    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()
-        fstr.add_child(String("Hello "))
-        fstr.add_child(name_expression)
-        fstr.add_child(String("!"))
-    """
-
-    def value(self) -> str:
-        parts = self.get_children()
-        return "".join(str(part.value()) for part in parts)

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

@@ -1,21 +0,0 @@
-"""Represents an identifier in the AST."""
-
-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")
-    """
-
-    def __str__(self) -> str:
-        return f"Identifier ({self._value})"
-
-    def value(self) -> Any:
-        return super().value()

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

@@ -1,32 +0,0 @@
-"""Represents a numeric literal in the AST."""
-
-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
-    """
-
-    def __init__(self, value: str):
-        """Creates a new Number node by parsing the string value.
-
-        Args:
-            value: The string representation of the number
-        """
-        super().__init__()
-        if '.' in value:
-            self._value = float(value)
-        else:
-            self._value = int(value)
-
-    def value(self) -> float | int:
-        return self._value
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__} ({self._value})"

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

@@ -1,271 +0,0 @@
-"""Operator classes for FlowQuery expressions."""
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-from ..ast_node import ASTNode
-
-
-class Operator(ASTNode, ABC):
-    """Base class for all operators in FlowQuery."""
-
-    def __init__(self, precedence: int, left_associative: bool):
-        super().__init__()
-        self._precedence = precedence
-        self._left_associative = left_associative
-
-    def is_operator(self) -> bool:
-        return True
-
-    @property
-    def precedence(self) -> int:
-        return self._precedence
-
-    @property
-    def left_associative(self) -> bool:
-        return self._left_associative
-
-    @abstractmethod
-    def value(self) -> Any:
-        pass
-
-    @property
-    def lhs(self) -> ASTNode:
-        return self.get_children()[0]
-
-    @property
-    def rhs(self) -> ASTNode:
-        return self.get_children()[1]
-
-
-class Add(Operator):
-    def __init__(self) -> None:
-        super().__init__(1, True)
-
-    def value(self) -> Any:
-        return self.lhs.value() + self.rhs.value()
-
-
-class Subtract(Operator):
-    def __init__(self) -> None:
-        super().__init__(1, True)
-
-    def value(self) -> Any:
-        return self.lhs.value() - self.rhs.value()
-
-
-class Multiply(Operator):
-    def __init__(self) -> None:
-        super().__init__(2, True)
-
-    def value(self) -> Any:
-        return self.lhs.value() * self.rhs.value()
-
-
-class Divide(Operator):
-    def __init__(self) -> None:
-        super().__init__(2, True)
-
-    def value(self) -> Any:
-        return self.lhs.value() / self.rhs.value()
-
-
-class Modulo(Operator):
-    def __init__(self) -> None:
-        super().__init__(2, True)
-
-    def value(self) -> Any:
-        return self.lhs.value() % self.rhs.value()
-
-
-class Power(Operator):
-    def __init__(self) -> None:
-        super().__init__(3, False)
-
-    def value(self) -> Any:
-        return self.lhs.value() ** self.rhs.value()
-
-
-class Equals(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() == self.rhs.value() else 0
-
-
-class NotEquals(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() != self.rhs.value() else 0
-
-
-class GreaterThan(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() > self.rhs.value() else 0
-
-
-class LessThan(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() < self.rhs.value() else 0
-
-
-class GreaterThanOrEqual(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() >= self.rhs.value() else 0
-
-
-class LessThanOrEqual(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() <= self.rhs.value() else 0
-
-
-class And(Operator):
-    def __init__(self) -> None:
-        super().__init__(-1, True)
-
-    def value(self) -> int:
-        return 1 if (self.lhs.value() and self.rhs.value()) else 0
-
-
-class Or(Operator):
-    def __init__(self) -> None:
-        super().__init__(-1, True)
-
-    def value(self) -> int:
-        return 1 if (self.lhs.value() or self.rhs.value()) else 0
-
-
-class Not(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def is_operator(self) -> bool:
-        return False
-
-    def value(self) -> int:
-        return 1 if not self.lhs.value() else 0
-
-
-class Is(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() == self.rhs.value() else 0
-
-
-class IsNot(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        return 1 if self.lhs.value() != self.rhs.value() else 0
-
-
-class In(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        lst = self.rhs.value()
-        if not isinstance(lst, list):
-            raise ValueError("Right operand of IN must be a list")
-        return 1 if self.lhs.value() in lst else 0
-
-
-class NotIn(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        lst = self.rhs.value()
-        if not isinstance(lst, list):
-            raise ValueError("Right operand of NOT IN must be a list")
-        return 0 if self.lhs.value() in lst else 1
-
-
-class Contains(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        s = self.lhs.value()
-        search = self.rhs.value()
-        if not isinstance(s, str) or not isinstance(search, str):
-            raise ValueError("CONTAINS requires string operands")
-        return 1 if search in s else 0
-
-
-class NotContains(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        s = self.lhs.value()
-        search = self.rhs.value()
-        if not isinstance(s, str) or not isinstance(search, str):
-            raise ValueError("NOT CONTAINS requires string operands")
-        return 0 if search in s else 1
-
-
-class StartsWith(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        s = self.lhs.value()
-        search = self.rhs.value()
-        if not isinstance(s, str) or not isinstance(search, str):
-            raise ValueError("STARTS WITH requires string operands")
-        return 1 if s.startswith(search) else 0
-
-
-class NotStartsWith(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        s = self.lhs.value()
-        search = self.rhs.value()
-        if not isinstance(s, str) or not isinstance(search, str):
-            raise ValueError("NOT STARTS WITH requires string operands")
-        return 0 if s.startswith(search) else 1
-
-
-class EndsWith(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        s = self.lhs.value()
-        search = self.rhs.value()
-        if not isinstance(s, str) or not isinstance(search, str):
-            raise ValueError("ENDS WITH requires string operands")
-        return 1 if s.endswith(search) else 0
-
-
-class NotEndsWith(Operator):
-    def __init__(self) -> None:
-        super().__init__(0, True)
-
-    def value(self) -> int:
-        s = self.lhs.value()
-        search = self.rhs.value()
-        if not isinstance(s, str) or not isinstance(search, str):
-            raise ValueError("NOT ENDS WITH requires string operands")
-        return 0 if s.endswith(search) else 1

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

@@ -1,47 +0,0 @@
-"""Represents a reference to a previously defined variable or expression."""
-
-from typing import Any, Optional
-
-from ..ast_node import ASTNode
-from .identifier import Identifier
-
-
-class Reference(Identifier):
-    """Represents a reference to a previously defined variable or expression.
-
-    References point to values defined earlier in the query (e.g., in WITH or LOAD statements).
-
-    Example:
-        ref = Reference("myVar", previous_node)
-        print(ref.value())  # Gets value from referred node
-    """
-
-    def __init__(self, value: str, referred: Optional[ASTNode] = None):
-        """Creates a new Reference to a variable.
-
-        Args:
-            value: The identifier name
-            referred: The node this reference points to (optional)
-        """
-        super().__init__(value)
-        self._referred = referred
-
-    @property
-    def referred(self) -> Optional[ASTNode]:
-        return self._referred
-
-    @referred.setter
-    def referred(self, node: ASTNode) -> None:
-        self._referred = node
-
-    def __str__(self) -> str:
-        return f"Reference ({self._value})"
-
-    def value(self) -> Any:
-        if self._referred is not None:
-            return self._referred.value()
-        return None
-
-    @property
-    def identifier(self) -> str:
-        return self._value

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

@@ -1,27 +0,0 @@
-"""Represents a string literal in the AST."""
-
-from ..ast_node import ASTNode
-
-
-class String(ASTNode):
-    """Represents a string literal in the AST.
-
-    Example:
-        s = String("hello")
-        print(s.value())  # "hello"
-    """
-
-    def __init__(self, value: str):
-        """Creates a new String node with the given value.
-
-        Args:
-            value: The string value
-        """
-        super().__init__()
-        self._value = value
-
-    def value(self) -> str:
-        return self._value
-
-    def __str__(self) -> str:
-        return f"String ({self._value})"

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

@@ -1,127 +0,0 @@
-"""Functions module for FlowQuery parsing."""
-
-from .aggregate_function import AggregateFunction
-from .async_function import AsyncFunction
-from .avg import Avg
-from .coalesce import Coalesce
-from .collect import Collect
-from .count import Count
-from .date_ import DateFunction
-from .datetime_ import Datetime
-from .duration import Duration
-from .element_id import ElementId
-from .function import Function
-from .function_factory import FunctionFactory
-from .function_metadata import (
-    FunctionCategory,
-    FunctionDef,
-    FunctionDefOptions,
-    FunctionMetadata,
-    OutputSchema,
-    ParameterSchema,
-    get_function_metadata,
-    get_registered_function_factory,
-    get_registered_function_metadata,
-)
-from .functions import Functions
-from .head import Head
-from .id_ import Id
-from .join import Join
-from .keys import Keys
-from .last import Last
-from .localdatetime import LocalDatetime
-from .localtime import LocalTime
-from .max_ import Max
-from .min_ import Min
-from .nodes import Nodes
-from .predicate_function import PredicateFunction
-from .predicate_sum import PredicateSum
-from .properties import Properties
-from .rand import Rand
-from .range_ import Range
-from .reducer_element import ReducerElement
-from .relationships import Relationships
-from .replace import Replace
-from .round_ import Round
-from .schema import Schema
-from .size import Size
-from .split import Split
-from .string_distance import StringDistance
-from .stringify import Stringify
-from .substring import Substring
-from .sum import Sum
-from .tail import Tail
-from .time_ import Time
-from .timestamp import Timestamp
-from .to_float import ToFloat
-from .to_integer import ToInteger
-from .to_json import ToJson
-from .to_lower import ToLower
-from .to_string import ToString
-from .trim import Trim
-from .type_ import Type
-from .value_holder import ValueHolder
-
-__all__ = [
-    # Base classes
-    "Function",
-    "AggregateFunction",
-    "AsyncFunction",
-    "PredicateFunction",
-    "ReducerElement",
-    "ValueHolder",
-    "FunctionCategory",
-    "ParameterSchema",
-    "OutputSchema",
-    "FunctionMetadata",
-    "FunctionDef",
-    "FunctionDefOptions",
-    "get_registered_function_metadata",
-    "get_registered_function_factory",
-    "get_function_metadata",
-    "FunctionFactory",
-    # Built-in functions
-    "Sum",
-    "Avg",
-    "DateFunction",
-    "Datetime",
-    "Coalesce",
-    "Collect",
-    "Count",
-    "Duration",
-    "ElementId",
-    "Head",
-    "Id",
-    "Join",
-    "Last",
-    "Keys",
-    "Max",
-    "Min",
-    "Nodes",
-    "Properties",
-    "Relationships",
-    "Rand",
-    "Range",
-    "Replace",
-    "Round",
-    "Size",
-    "Split",
-    "StringDistance",
-    "Stringify",
-    "Substring",
-    "Tail",
-    "Time",
-    "Timestamp",
-    "ToFloat",
-    "ToInteger",
-    "ToJson",
-    "ToLower",
-    "ToString",
-    "Trim",
-    "Type",
-    "LocalDatetime",
-    "LocalTime",
-    "Functions",
-    "Schema",
-    "PredicateSum",
-]

package/flowquery-py/src/parsing/functions/aggregate_function.py

@@ -1,60 +0,0 @@
-"""Base class for aggregate functions that reduce multiple values to a single value."""
-
-from typing import Any, Optional
-
-from .function import Function
-from .reducer_element import ReducerElement
-
-
-class AggregateFunction(Function):
-    """Base class for aggregate functions that reduce multiple values to a single value.
-
-    Aggregate functions like SUM, AVG, and COLLECT process multiple input values
-    and produce a single output. They cannot be nested within other aggregate functions.
-
-    Example:
-        sum_func = Sum()
-        # Used in: RETURN SUM(values)
-    """
-
-    def __init__(self, name: Optional[str] = None):
-        """Creates a new AggregateFunction with the given name.
-
-        Args:
-            name: The function name
-        """
-        super().__init__(name)
-        self._overridden: Any = None
-
-    def reduce(self, value: Any) -> None:
-        """Processes a value during the aggregation phase.
-
-        Args:
-            value: The element to aggregate
-
-        Raises:
-            NotImplementedError: If not implemented by subclass
-        """
-        raise NotImplementedError("Method not implemented.")
-
-    def element(self) -> ReducerElement:
-        """Creates a reducer element for this aggregate function.
-
-        Returns:
-            A ReducerElement instance
-
-        Raises:
-            NotImplementedError: If not implemented by subclass
-        """
-        raise NotImplementedError("Method not implemented.")
-
-    @property
-    def overridden(self) -> Any:
-        return self._overridden
-
-    @overridden.setter
-    def overridden(self, value: Any) -> None:
-        self._overridden = value
-
-    def value(self) -> Any:
-        return self._overridden

package/flowquery-py/src/parsing/functions/async_function.py

@@ -1,65 +0,0 @@
-"""Represents an async data provider function call for use in LOAD operations."""
-
-from typing import Any, AsyncGenerator, List
-
-from ..ast_node import ASTNode
-from .function import Function
-
-
-class AsyncFunction(Function):
-    """Represents an async data provider function call for use in LOAD operations.
-
-    This class holds the function name and arguments, and provides async iteration
-    over the results from a registered async data provider.
-
-    Example:
-        # Used in: LOAD JSON FROM myDataSource('arg1', 'arg2') AS data
-        async_func = AsyncFunction("myDataSource")
-        async_func.parameters = [arg1_node, arg2_node]
-        async for item in async_func.execute():
-            print(item)
-    """
-
-    @property
-    def parameters(self) -> List[ASTNode]:
-        return self.children
-
-    @parameters.setter
-    def parameters(self, nodes: List[ASTNode]) -> None:
-        """Sets the function parameters.
-
-        Args:
-            nodes: Array of AST nodes representing the function arguments
-        """
-        self.children = nodes
-
-    def get_arguments(self) -> List[Any]:
-        """Evaluates all parameters and returns their values.
-        Used by the framework to pass arguments to generate().
-
-        Returns:
-            Array of parameter values
-        """
-        return [child.value() for child in self.children]
-
-    async def generate(self, *args: Any) -> AsyncGenerator[Any, None]:
-        """Generates the async data provider function results.
-
-        Subclasses override this method with their own typed parameters.
-        The framework automatically evaluates the AST children and spreads
-        them as arguments when calling this method.
-
-        Args:
-            args: Arguments passed from the query (e.g., myFunc(arg1, arg2))
-
-        Yields:
-            Data items from the async provider
-
-        Raises:
-            NotImplementedError: If the function is not registered as an async provider
-        """
-        raise NotImplementedError("generate method must be overridden in subclasses.")
-        # Note: yield is here only to make this a generator function
-        # It will never be reached due to the raise above
-        if False:  # pragma: no cover
-            yield  # Make this a generator