flowquery 1.0.46 → 1.0.48

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

@@ -1,148 +0,0 @@
-"""GroupBy implementation for aggregate operations."""
-
-import json
-from typing import Any, Dict, Generator, List, Optional
-
-from ..ast_node import ASTNode
-from ..functions.aggregate_function import AggregateFunction
-from ..functions.reducer_element import ReducerElement
-from .projection import Projection
-
-
-def _make_hashable(value: Any) -> Any:
-    """Convert a value to a hashable form for use as a dict key."""
-    if isinstance(value, dict):
-        return json.dumps(value, sort_keys=True, default=str)
-    if isinstance(value, list):
-        return json.dumps(value, sort_keys=True, default=str)
-    return value
-
-
-class GroupByNode:
-    """Represents a node in the group-by tree."""
-
-    def __init__(self, value: Any = None):
-        self._value = value
-        self._children: Dict[Any, 'GroupByNode'] = {}
-        self._elements: Optional[List[ReducerElement]] = None
-
-    @property
-    def value(self) -> Any:
-        return self._value
-
-    @property
-    def children(self) -> Dict[Any, 'GroupByNode']:
-        return self._children
-
-    @property
-    def elements(self) -> Optional[List[ReducerElement]]:
-        return self._elements
-
-    @elements.setter
-    def elements(self, elements: List[ReducerElement]) -> None:
-        self._elements = elements
-
-
-class GroupBy(Projection):
-    """Implements grouping and aggregation for FlowQuery operations."""
-
-    def __init__(self, expressions: List[ASTNode]) -> None:
-        super().__init__(expressions)
-        self._root = GroupByNode()
-        self._current = self._root
-        self._mappers: Optional[List[Any]] = None
-        self._reducers: Optional[List[AggregateFunction]] = None
-        self._where: Optional[ASTNode] = None
-
-    async def run(self) -> None:
-        self._reset_tree()
-        self._map()
-        self._reduce()
-
-    @property
-    def _root_node(self) -> GroupByNode:
-        return self._root
-
-    def _reset_tree(self) -> None:
-        self._current = self._root
-
-    def _map(self) -> None:
-        node = self._current
-        for mapper in self.mappers:
-            value = mapper.value()
-            key = _make_hashable(value)
-            child = node.children.get(key)
-            if child is None:
-                child = GroupByNode(value)
-                node.children[key] = child
-            node = child
-        self._current = node
-
-    def _reduce(self) -> None:
-        if self._current.elements is None:
-            self._current.elements = [reducer.element() for reducer in self.reducers]
-        elements = self._current.elements
-        if elements:
-            for i, reducer in enumerate(self.reducers):
-                reducer.reduce(elements[i])
-
-    @property
-    def mappers(self) -> List[Any]:
-        if self._mappers is None:
-            self._mappers = list(self._generate_mappers())
-        return self._mappers
-
-    def _generate_mappers(self) -> Generator[Any, None, None]:
-        for expression, _ in self.expressions():
-            if hasattr(expression, 'mappable') and expression.mappable():
-                yield expression
-
-    @property
-    def reducers(self) -> List[AggregateFunction]:
-        if self._reducers is None:
-            self._reducers = []
-            for child in self.children:
-                if hasattr(child, 'reducers'):
-                    self._reducers.extend(child.reducers())
-        return self._reducers
-
-    def generate_results(
-        self,
-        mapper_index: int = 0,
-        node: Optional[GroupByNode] = None
-    ) -> Generator[Dict[str, Any], None, None]:
-        if node is None:
-            node = self._root
-
-        if mapper_index == 0 and len(node.children) == 0 and len(self.mappers) > 0:
-            return
-
-        if len(node.children) > 0:
-            for child in node.children.values():
-                self.mappers[mapper_index].overridden = child.value
-                yield from self.generate_results(mapper_index + 1, child)
-        else:
-            if node.elements is None:
-                node.elements = [reducer.element() for reducer in self.reducers]
-            if node.elements:
-                for i, element in enumerate(node.elements):
-                    self.reducers[i].overridden = element.value
-            record: Dict[str, Any] = {}
-            for expression, alias in self.expressions():
-                record[alias] = expression.value()
-            if self.where_condition:
-                yield record
-
-    @property
-    def where(self) -> Optional[ASTNode]:
-        return self._where
-
-    @where.setter
-    def where(self, where: Optional[ASTNode]) -> None:
-        self._where = where
-
-    @property
-    def where_condition(self) -> Any:
-        if self._where is None:
-            return True
-        return self._where.value()

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

@@ -1,33 +0,0 @@
-"""Represents a LIMIT operation that limits the number of results."""
-
-from .operation import Operation
-
-
-class Limit(Operation):
-    """Represents a LIMIT operation that limits the number of results."""
-
-    def __init__(self, limit: int):
-        super().__init__()
-        self._count = 0
-        self._limit = limit
-
-    @property
-    def is_limit_reached(self) -> bool:
-        return self._count >= self._limit
-
-    @property
-    def limit_value(self) -> int:
-        return self._limit
-
-    def increment(self) -> None:
-        self._count += 1
-
-    async def run(self) -> None:
-        if self._count >= self._limit:
-            return
-        self._count += 1
-        if self.next:
-            await self.next.run()
-
-    def reset(self) -> None:
-        self._count = 0

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

@@ -1,148 +0,0 @@
-"""Represents a LOAD operation that fetches data from external sources."""
-
-import json
-from typing import Any, Dict, Optional
-
-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) -> None:
-        super().__init__()
-        self._value: Any = None
-
-    @property
-    def type(self) -> ASTNode:
-        """Gets the data type (JSON, CSV, or Text)."""
-        return self.children[0]
-
-    @property
-    def from_component(self) -> ASTNode:
-        """Gets the From component which contains either a URL expression or an AsyncFunction."""
-        return self.children[1]
-
-    @property
-    def is_async_function(self) -> bool:
-        """Checks if the data source is an async function."""
-        return isinstance(self.from_component.first_child(), AsyncFunction)
-
-    @property
-    def async_function(self) -> Optional[AsyncFunction]:
-        """Gets the async function if the source is a function, otherwise None."""
-        child = self.from_component.first_child()
-        return child if isinstance(child, AsyncFunction) else None
-
-    @property
-    def from_(self) -> Any:
-        return self.children[1].value()
-
-    @property
-    def headers(self) -> Dict[str, str]:
-        if self.child_count() > 2 and isinstance(self.children[2], Headers):
-            return self.children[2].value() or {}
-        return {}
-
-    @property
-    def payload(self) -> Optional[ASTNode]:
-        post = None
-        if self.child_count() > 2 and isinstance(self.children[2], Post):
-            post = self.children[2]
-        elif self.child_count() > 3 and isinstance(self.children[3], Post):
-            post = self.children[3]
-        return post.first_child() if post else None
-
-    def _method(self) -> str:
-        return "GET" if self.payload is None else "POST"
-
-    def _options(self) -> Dict[str, Any]:
-        headers = dict(self.headers)
-        payload = self.payload
-        data = payload.value() if payload else None
-        if data is not None and isinstance(data, dict) and "Content-Type" not in headers:
-            headers["Content-Type"] = "application/json"
-        options: Dict[str, Any] = {
-            "method": self._method(),
-            "headers": headers,
-        }
-        if payload is not None:
-            options["body"] = json.dumps(payload.value())
-        return options
-
-    async def _load_from_function(self) -> None:
-        """Loads data from an async function source."""
-        async_func = self.async_function
-        if async_func is None:
-            return
-        args = async_func.get_arguments()
-        async for item in async_func.generate(*args):
-            self._value = item
-            if self.next:
-                await self.next.run()
-
-    async def _load_from_url(self) -> None:
-        """Loads data from a URL source."""
-        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,
-                data=body
-            ) as response:
-                if isinstance(self.type, JSONComponent):
-                    data = await response.json()
-                elif isinstance(self.type, Text):
-                    data = await response.text()
-                else:
-                    data = await response.text()
-
-                if isinstance(data, list):
-                    for item in data:
-                        self._value = item
-                        if self.next:
-                            await self.next.run()
-                elif isinstance(data, dict):
-                    self._value = data
-                    if self.next:
-                        await self.next.run()
-                elif isinstance(data, str):
-                    self._value = data
-                    if self.next:
-                        await self.next.run()
-
-    async def load(self) -> None:
-        if self.is_async_function:
-            await self._load_from_function()
-        else:
-            await self._load_from_url()
-
-    async def run(self) -> None:
-        try:
-            await self.load()
-        except Exception as e:
-            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:
-        return self._value

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

@@ -1,52 +0,0 @@
-"""Represents a MATCH operation for graph pattern matching."""
-
-from typing import List, Optional
-
-from ...graph.node import Node
-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: Optional[List[Pattern]] = None, optional: bool = False) -> None:
-        super().__init__()
-        self._patterns = Patterns(patterns or [])
-        self._optional = optional
-
-    @property
-    def patterns(self) -> List[Pattern]:
-        return self._patterns.patterns if self._patterns else []
-
-    @property
-    def optional(self) -> bool:
-        return self._optional
-
-    def __str__(self) -> str:
-        return "OptionalMatch" if self._optional else "Match"
-
-    async def run(self) -> None:
-        """Executes the match operation by chaining the patterns together.
-        If optional and no match is found, continues with null values."""
-        await self._patterns.initialize()
-        matched = False
-
-        async def to_do_next() -> None:
-            nonlocal matched
-            matched = True
-            if self.next:
-                await self.next.run()
-
-        self._patterns.to_do_next = to_do_next
-        await self._patterns.traverse()
-
-        # For OPTIONAL MATCH: if nothing matched, continue with None values
-        if not matched and self._optional:
-            for pattern in self._patterns.patterns:
-                for element in pattern.chain:
-                    if isinstance(element, Node):
-                        element.set_value(None)
-            if self.next:
-                await self.next.run()

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

@@ -1,69 +0,0 @@
-"""Base class for all FlowQuery operations."""
-
-from abc import ABC
-from typing import Any, Dict, List, Optional
-
-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) -> None:
-        super().__init__()
-        self._previous: Optional[Operation] = None
-        self._next: Optional[Operation] = None
-
-    @property
-    def previous(self) -> Optional['Operation']:
-        return self._previous
-
-    @previous.setter
-    def previous(self, value: Optional['Operation']) -> None:
-        self._previous = value
-
-    @property
-    def next(self) -> Optional['Operation']:
-        return self._next
-
-    @next.setter
-    def next(self, value: Optional['Operation']) -> None:
-        self._next = value
-
-    def add_sibling(self, operation: 'Operation') -> None:
-        if self._parent:
-            self._parent.add_child(operation)
-        operation.previous = self
-        self.next = operation
-
-    @property
-    def is_last(self) -> bool:
-        return self._next is None
-
-    async def run(self) -> None:
-        """Executes this operation. Must be implemented by subclasses.
-
-        Raises:
-            NotImplementedError: If not implemented by subclass
-        """
-        raise NotImplementedError("Not implemented")
-
-    async def finish(self) -> None:
-        """Finishes execution by calling finish on the next operation in the chain."""
-        if self.next:
-            await self.next.finish()
-
-    async def initialize(self) -> None:
-        if self.next:
-            await self.next.initialize()
-
-    def reset(self) -> None:
-        pass
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        raise NotImplementedError("Not implemented")

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

@@ -1,114 +0,0 @@
-"""Represents an ORDER BY operation that sorts results."""
-
-import functools
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
-
-from .operation import Operation
-
-if TYPE_CHECKING:
-    from ..expressions.expression import Expression
-
-
-class SortField:
-    """A single sort specification: expression and direction."""
-
-    def __init__(self, expression: 'Expression', direction: str = "asc"):
-        self.expression = expression
-        self.direction = direction
-
-
-class OrderBy(Operation):
-    """Represents an ORDER BY operation that sorts results.
-
-    Can be attached to a RETURN operation (sorting its results),
-    or used as a standalone accumulating operation after a non-aggregate WITH.
-
-    Supports both simple field references and arbitrary expressions:
-
-    Example::
-
-        RETURN x ORDER BY x DESC
-        RETURN x ORDER BY toLower(x.name) ASC
-        RETURN x ORDER BY string_distance(toLower(x.name), toLower('Thomas')) ASC
-    """
-
-    def __init__(self, fields: List[SortField]):
-        super().__init__()
-        self._fields = fields
-        self._results: List[Dict[str, Any]] = []
-        self._sort_keys: List[List[Any]] = []
-
-    @property
-    def fields(self) -> List[SortField]:
-        return self._fields
-
-    def capture_sort_keys(self) -> None:
-        """Evaluate every sort-field expression against the current runtime
-        context and store the resulting values.  Must be called once per
-        accumulated row (from ``Return.run()``)."""
-        self._sort_keys.append([f.expression.value() for f in self._fields])
-
-    def sort(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Sort records using pre-computed sort keys captured during
-        accumulation.  When no keys have been captured (e.g. aggregated
-        returns), falls back to looking up simple reference identifiers
-        in each record."""
-        from ..expressions.reference import Reference
-
-        use_keys = len(self._sort_keys) == len(records)
-        keys = self._sort_keys
-
-        # Pre-compute fallback field names for when sort keys aren't
-        # available (aggregated returns).
-        fallback_fields: List[Optional[str]] = []
-        for f in self._fields:
-            root = f.expression.first_child()
-            if isinstance(root, Reference) and f.expression.child_count() == 1:
-                fallback_fields.append(root.identifier)
-            else:
-                fallback_fields.append(None)
-
-        indices = list(range(len(records)))
-
-        def compare(ai: int, bi: int) -> int:
-            for f_idx, sf in enumerate(self._fields):
-                if use_keys:
-                    a_val = keys[ai][f_idx]
-                    b_val = keys[bi][f_idx]
-                elif fallback_fields[f_idx] is not None:
-                    a_val = records[ai].get(fallback_fields[f_idx])  # type: ignore[arg-type]
-                    b_val = records[bi].get(fallback_fields[f_idx])  # type: ignore[arg-type]
-                else:
-                    continue
-                cmp = 0
-                if a_val is None and b_val is None:
-                    cmp = 0
-                elif a_val is None:
-                    cmp = -1
-                elif b_val is None:
-                    cmp = 1
-                elif a_val < b_val:
-                    cmp = -1
-                elif a_val > b_val:
-                    cmp = 1
-                if cmp != 0:
-                    return -cmp if sf.direction == "desc" else cmp
-            return 0
-
-        indices.sort(key=functools.cmp_to_key(compare))
-        return [records[i] for i in indices]
-
-    async def run(self) -> None:
-        """When used as a standalone operation, passes through to next."""
-        if self.next:
-            await self.next.run()
-
-    async def initialize(self) -> None:
-        self._results = []
-        self._sort_keys = []
-        if self.next:
-            await self.next.initialize()
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        return self._results

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

@@ -1,21 +0,0 @@
-"""Base class for projection operations."""
-
-from typing import Any, Generator, List, Tuple
-
-from ..ast_node import ASTNode
-from .operation import Operation
-
-
-class Projection(Operation):
-    """Base class for operations that project expressions."""
-
-    def __init__(self, expressions: List[ASTNode]):
-        super().__init__()
-        self.children = expressions
-
-    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 = child
-            alias = getattr(expression, 'alias', None) or f"expr{i}"
-            yield (expression, alias)

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

@@ -1,88 +0,0 @@
-"""Represents a RETURN operation that produces the final query results."""
-
-import copy
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
-
-from ..ast_node import ASTNode
-from .limit import Limit
-from .order_by import OrderBy
-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: List[ASTNode]) -> None:
-        super().__init__(expressions)
-        self._where: Optional['Where'] = None
-        self._results: List[Dict[str, Any]] = []
-        self._limit: Optional[Limit] = None
-        self._order_by: Optional[OrderBy] = None
-
-    @property
-    def where(self) -> Any:
-        if self._where is None:
-            return True
-        return self._where.value()
-
-    @where.setter
-    def where(self, where: 'Where') -> None:
-        self._where = where
-
-    @property
-    def limit(self) -> Optional[Limit]:
-        return self._limit
-
-    @limit.setter
-    def limit(self, limit: Limit) -> None:
-        self._limit = limit
-
-    @property
-    def order_by(self) -> Optional[OrderBy]:
-        return self._order_by
-
-    @order_by.setter
-    def order_by(self, order_by: OrderBy) -> None:
-        self._order_by = order_by
-
-    async def run(self) -> None:
-        if not self.where:
-            return
-        # When ORDER BY is present, skip limit during accumulation;
-        # limit will be applied after sorting in results property
-        if self._order_by is None and self._limit is not None and self._limit.is_limit_reached:
-            return
-        record: Dict[str, Any] = {}
-        for expression, alias in self.expressions():
-            raw = expression.value()
-            # Deep copy objects to preserve their state
-            value = copy.deepcopy(raw) if isinstance(raw, (dict, list)) else raw
-            record[alias] = value
-        # Capture sort-key values while expression bindings are still live.
-        if self._order_by is not None:
-            self._order_by.capture_sort_keys()
-        self._results.append(record)
-        if self._order_by is None and self._limit is not None:
-            self._limit.increment()
-
-    async def initialize(self) -> None:
-        self._results = []
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        result = self._results
-        if self._order_by is not None:
-            result = self._order_by.sort(result)
-        if self._order_by is not None and self._limit is not None:
-            result = result[:self._limit.limit_value]
-        return result