flowquery 1.0.46 → 1.0.48

package/flowquery-py/src/graph/relationship.py

@@ -1,193 +0,0 @@
-"""Graph relationship representation for FlowQuery."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
-
-from ..parsing.ast_node import ASTNode
-from .hops import Hops
-from .relationship_data import RelationshipData
-from .relationship_match_collector import RelationshipMatchCollector, RelationshipMatchRecord
-
-if TYPE_CHECKING:
-    from .node import Node
-
-
-class Relationship(ASTNode):
-    """Represents a relationship in a graph pattern."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._identifier: Optional[str] = None
-        self._types: List[str] = []
-        self._hops: Hops = Hops()
-        self._source: Optional['Node'] = None
-        self._target: Optional['Node'] = None
-        self._direction: str = "right"
-        self._data: Optional['RelationshipData'] = None
-        self._value: Optional[Union[RelationshipMatchRecord, List[RelationshipMatchRecord]]] = None
-        self._matches: RelationshipMatchCollector = RelationshipMatchCollector()
-        self._properties: Dict[str, Any] = {}
-
-    @property
-    def identifier(self) -> Optional[str]:
-        return self._identifier
-
-    @identifier.setter
-    def identifier(self, value: str) -> None:
-        self._identifier = value
-
-    @property
-    def type(self) -> Optional[str]:
-        return self._types[0] if self._types else None
-
-    @type.setter
-    def type(self, value: str) -> None:
-        self._types = [value]
-
-    @property
-    def types(self) -> List[str]:
-        return self._types
-
-    @types.setter
-    def types(self, value: List[str]) -> None:
-        self._types = value
-
-    @property
-    def hops(self) -> Hops:
-        return self._hops
-
-    @hops.setter
-    def hops(self, value: Hops) -> None:
-        self._hops = value
-
-    @property
-    def properties(self) -> Dict[str, Any]:
-        return self._properties
-
-    @properties.setter
-    def properties(self, value: Dict[str, Any]) -> None:
-        self._properties = value
-
-    def _matches_properties(self, hop: int = 0) -> bool:
-        """Check if current record matches all constraint properties."""
-        if not self._properties:
-            return True
-        if self._data is None:
-            return True
-        for key, expression in self._properties.items():
-            record = self._data.current(hop)
-            if record is None:
-                raise ValueError("No current relationship data available")
-            if key not in record:
-                raise ValueError("Relationship does not have property")
-            return bool(record[key] == expression.value())
-        return True
-
-    @property
-    def source(self) -> Optional['Node']:
-        return self._source
-
-    @source.setter
-    def source(self, value: 'Node') -> None:
-        self._source = value
-
-    @property
-    def target(self) -> Optional['Node']:
-        return self._target
-
-    @target.setter
-    def target(self, value: 'Node') -> None:
-        self._target = value
-
-    @property
-    def direction(self) -> str:
-        return self._direction
-
-    @direction.setter
-    def direction(self, value: str) -> None:
-        self._direction = value
-
-    # Keep start/end aliases for backward compatibility
-    @property
-    def start(self) -> Optional['Node']:
-        return self._source
-
-    @start.setter
-    def start(self, value: 'Node') -> None:
-        self._source = value
-
-    @property
-    def end(self) -> Optional['Node']:
-        return self._target
-
-    @end.setter
-    def end(self, value: 'Node') -> None:
-        self._target = value
-
-    def set_data(self, data: Optional['RelationshipData']) -> None:
-        self._data = data
-
-    def get_data(self) -> Optional['RelationshipData']:
-        return self._data
-
-    def set_value(self, relationship: 'Relationship', traversal_id: str = "") -> None:
-        """Set value by pushing match to collector."""
-        self._matches.push(relationship, traversal_id)
-        self._value = self._matches.value()
-
-    def value(self) -> Optional[Union[RelationshipMatchRecord, List[RelationshipMatchRecord]]]:
-        return self._value
-
-    @property
-    def matches(self) -> List[RelationshipMatchRecord]:
-        return self._matches.matches
-
-    def set_end_node(self, node: 'Node') -> None:
-        """Set the end node for the current match."""
-        self._matches.end_node = node
-
-    def _left_id_or_right_id(self) -> str:
-        return "left_id" if self._direction == "left" else "right_id"
-
-    async def find(self, left_id: str, hop: int = 0) -> None:
-        """Find relationships starting from the given node ID."""
-        # Save original source node
-        original = self._source
-        if hop > 0:
-            # For hops greater than 0, the source becomes the target of the previous hop
-            self._source = self._target
-        if hop == 0:
-            if self._data:
-                self._data.reset()
-
-            # Handle zero-hop case: when min is 0 on a variable-length relationship,
-            # match source node as target (no traversal)
-            if self._hops and self._hops.multi() and self._hops.min == 0 and self._target:
-                # For zero-hop, target finds the same node as source (left_id)
-                # No relationship match is pushed since no edge is traversed
-                await self._target.find(left_id, hop)
-
-        while self._data and self._data.find(left_id, hop, self._direction):
-            data = self._data.current(hop)
-            if data is None:
-                continue
-            id = data[self._left_id_or_right_id()]
-            if hop + 1 >= self._hops.min:
-                self.set_value(self, left_id)
-                if not self._matches_properties(hop):
-                    continue
-                if self._target:
-                    await self._target.find(id, hop)
-                if hop + 1 < self._hops.max:
-                    if self._matches.is_circular(id):
-                        self._matches.pop()
-                        continue
-                    await self.find(id, hop + 1)
-                self._matches.pop()
-            else:
-                # Below minimum hops: traverse the edge without yielding a match
-                await self.find(id, hop + 1)
-
-        # Restore original source node
-        self._source = original

package/flowquery-py/src/graph/relationship_data.py

@@ -1,36 +0,0 @@
-"""Relationship data class for FlowQuery."""
-
-from typing import Any, Dict, List, Optional, TypedDict
-
-from .data import Data
-
-
-class RelationshipRecord(TypedDict, total=False):
-    """Represents a relationship record from the database."""
-    left_id: str
-    right_id: str
-
-
-class RelationshipData(Data):
-    """Relationship data class extending Data with left_id and right_id indexing."""
-
-    def __init__(self, records: Optional[List[Dict[str, Any]]] = None):
-        super().__init__(records)
-        self._build_index("left_id")
-        self._build_index("right_id")
-
-    def find(self, id: str, hop: int = 0, direction: str = "right") -> bool:
-        """Find a relationship by node ID and direction."""
-        key = "right_id" if direction == "left" else "left_id"
-        return self._find(id, hop, key)
-
-    def properties(self) -> Optional[Dict[str, Any]]:
-        """Get properties of current relationship, excluding left_id, right_id, and _type."""
-        current = self.current()
-        if current:
-            props = dict(current)
-            props.pop("left_id", None)
-            props.pop("right_id", None)
-            props.pop("_type", None)
-            return props
-        return None

package/flowquery-py/src/graph/relationship_match_collector.py

@@ -1,85 +0,0 @@
-"""Collector for relationship match records."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
-
-if TYPE_CHECKING:
-    from .node import Node
-    from .relationship import Relationship
-
-# A relationship match record is a plain dict with known keys (type,
-# startNode, endNode, properties) plus any extra relationship-property
-# keys spread at the top level – mirroring the TypeScript version that
-# uses an index signature ``[key: string]: any``.
-RelationshipMatchRecord = Dict[str, Any]
-
-
-class RelationshipMatchCollector:
-    """Collects relationship matches during graph traversal."""
-
-    def __init__(self) -> None:
-        self._matches: List[RelationshipMatchRecord] = []
-        self._node_ids: List[str] = []
-
-    def push(self, relationship: 'Relationship', traversal_id: str = "") -> RelationshipMatchRecord:
-        """Push a new match onto the collector."""
-        start_node_value = relationship.source.value() if relationship.source else None
-        rel_data = relationship.get_data()
-        current_record = rel_data.current() if rel_data else None
-        default_type = relationship.type or ""
-        if current_record and isinstance(current_record, dict):
-            actual_type = current_record.get('_type', default_type)
-        else:
-            actual_type = default_type
-        rel_props: Dict[str, Any] = (rel_data.properties() or {}) if rel_data else {}
-        match: RelationshipMatchRecord = {
-            **rel_props,
-            "type": actual_type,
-            "startNode": start_node_value or {},
-            "endNode": None,
-            "properties": rel_props,
-        }
-        self._matches.append(match)
-        self._node_ids.append(traversal_id)
-        return match
-
-    @property
-    def end_node(self) -> Any:
-        """Get the end node of the last match."""
-        if self._matches:
-            return self._matches[-1].get("endNode")
-        return None
-
-    @end_node.setter
-    def end_node(self, node: 'Node') -> None:
-        """Set the end node of the last match."""
-        if self._matches:
-            node_value = node.value()
-            self._matches[-1]["endNode"] = node_value if node_value else None
-
-    def pop(self) -> Optional[RelationshipMatchRecord]:
-        """Pop the last match from the collector."""
-        if self._node_ids:
-            self._node_ids.pop()
-        if self._matches:
-            return self._matches.pop()
-        return None
-
-    def value(self) -> Optional[Union[RelationshipMatchRecord, List[RelationshipMatchRecord]]]:
-        """Get the current value(s)."""
-        if len(self._matches) == 0:
-            return None
-        elif len(self._matches) == 1:
-            return self._matches[0]
-        else:
-            return self._matches
-
-    @property
-    def matches(self) -> List[RelationshipMatchRecord]:
-        """Get all matches."""
-        return self._matches
-
-    def is_circular(self, next_id: str = "") -> bool:
-        """Check if traversing to the given node id would form a cycle."""
-        return next_id in self._node_ids

package/flowquery-py/src/graph/relationship_reference.py

@@ -1,21 +0,0 @@
-from typing import Any, Optional
-
-from ..parsing.ast_node import ASTNode
-from .relationship import Relationship
-
-
-class RelationshipReference(Relationship):
-    """Represents a reference to an existing relationship variable."""
-
-    def __init__(self, relationship: Relationship, referred: ASTNode) -> None:
-        super().__init__()
-        self._referred = referred
-        if relationship.types:
-            self.types = relationship.types
-
-    @property
-    def referred(self) -> ASTNode:
-        return self._referred
-
-    def value(self) -> Optional[Any]:
-        return self._referred.value() if self._referred else None

package/flowquery-py/src/io/__init__.py

@@ -1,5 +0,0 @@
-"""IO module for FlowQuery."""
-
-from .command_line import CommandLine
-
-__all__ = ["CommandLine"]

package/flowquery-py/src/io/command_line.py

@@ -1,108 +0,0 @@
-"""Interactive command-line interface for FlowQuery."""
-
-import argparse
-import asyncio
-
-from ..compute.runner import Runner
-
-
-class CommandLine:
-    """Interactive command-line interface for FlowQuery.
-
-    Provides a REPL (Read-Eval-Print Loop) for executing FlowQuery statements
-    and displaying results.
-
-    Example:
-        cli = CommandLine()
-        cli.loop()  # Starts interactive mode
-
-        # Or execute a single query:
-        cli.execute("load json from 'https://example.com/data' as d return d")
-    """
-
-    def execute(self, query: str) -> None:
-        """Execute a single FlowQuery statement and print results.
-
-        Args:
-            query: The FlowQuery statement to execute.
-        """
-        # Remove the termination semicolon if present
-        query = query.strip().rstrip(";")
-
-        try:
-            runner = Runner(query)
-            asyncio.run(self._execute(runner))
-        except Exception as e:
-            print(f"Error: {e}")
-
-    def loop(self) -> None:
-        """Starts the interactive command loop.
-
-        Prompts the user for FlowQuery statements, executes them, and displays results.
-        Type "exit" to quit the loop. End multi-line queries with ";".
-        """
-        print('Welcome to FlowQuery! Type "exit" to quit.')
-        print('End queries with ";" to execute. Multi-line input supported.')
-
-        while True:
-            try:
-                lines = []
-                prompt = "> "
-                while True:
-                    line = input(prompt)
-                    if line.strip() == "exit":
-                        print("Exiting FlowQuery.")
-                        return
-                    lines.append(line)
-                    user_input = "\n".join(lines)
-                    if user_input.strip().endswith(";"):
-                        break
-                    prompt = "... "
-            except EOFError:
-                break
-
-            if user_input.strip() == "":
-                continue
-
-            # Remove the termination semicolon before sending to the engine
-            user_input = user_input.strip().rstrip(";")
-
-            try:
-                runner = Runner(user_input)
-                asyncio.run(self._execute(runner))
-            except Exception as e:
-                print(f"Error: {e}")
-
-        print("Exiting FlowQuery.")
-
-    async def _execute(self, runner: Runner) -> None:
-        await runner.run()
-        print(runner.results)
-
-
-def main() -> None:
-    """Entry point for the flowquery CLI command.
-
-    Usage:
-        flowquery              # Start interactive mode
-        flowquery -c "query"   # Execute a single query
-        flowquery --command "query"
-    """
-    parser = argparse.ArgumentParser(
-        description="FlowQuery - A declarative query language for data processing pipelines",
-        prog="flowquery"
-    )
-    parser.add_argument(
-        "-c", "--command",
-        type=str,
-        metavar="QUERY",
-        help="Execute a FlowQuery statement and exit"
-    )
-
-    args = parser.parse_args()
-    cli = CommandLine()
-
-    if args.command:
-        cli.execute(args.command)
-    else:
-        cli.loop()

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

@@ -1,17 +0,0 @@
-"""Parsing module for FlowQuery."""
-
-from .alias import Alias
-from .alias_option import AliasOption
-from .ast_node import ASTNode
-from .base_parser import BaseParser
-from .context import Context
-from .parser import Parser
-
-__all__ = [
-    "ASTNode",
-    "Context",
-    "Alias",
-    "AliasOption",
-    "BaseParser",
-    "Parser",
-]

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

@@ -1,20 +0,0 @@
-"""Alias node for FlowQuery AST."""
-
-from .ast_node import ASTNode
-
-
-class Alias(ASTNode):
-    """Represents an alias in the FlowQuery AST."""
-
-    def __init__(self, alias: str):
-        super().__init__()
-        self._alias = alias
-
-    def __str__(self) -> str:
-        return f"Alias ({self._alias})"
-
-    def get_alias(self) -> str:
-        return self._alias
-
-    def value(self) -> str:
-        return self._alias

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

@@ -1,11 +0,0 @@
-"""Alias option enumeration for FlowQuery parsing."""
-
-from enum import Enum
-
-
-class AliasOption(Enum):
-    """Enumeration of alias options for parsing."""
-
-    NOT_ALLOWED = 0
-    OPTIONAL = 1
-    REQUIRED = 2

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

@@ -1,147 +0,0 @@
-"""Represents a node in the Abstract Syntax Tree (AST)."""
-
-from __future__ import annotations
-
-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) -> 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
-        """
-        child._parent = self
-        self.children.append(child)
-
-    def first_child(self) -> ASTNode:
-        """Returns the first child node.
-
-        Returns:
-            The first child node
-
-        Raises:
-            ValueError: If the node has no children
-        """
-        if len(self.children) == 0:
-            raise ValueError('Expected child')
-        return self.children[0]
-
-    def last_child(self) -> ASTNode:
-        """Returns the last child node.
-
-        Returns:
-            The last child node
-
-        Raises:
-            ValueError: If the node has no children
-        """
-        if len(self.children) == 0:
-            raise ValueError('Expected child')
-        return self.children[-1]
-
-    def get_children(self) -> List[ASTNode]:
-        """Returns all child nodes.
-
-        Returns:
-            Array of child nodes
-        """
-        return self.children
-
-    def child_count(self) -> int:
-        """Returns the number of child nodes.
-
-        Returns:
-            The count of children
-        """
-        return len(self.children)
-
-    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
-        """
-        return None
-
-    def is_operator(self) -> bool:
-        """Checks if this node represents an operator.
-
-        Returns:
-            True if this is an operator node, False otherwise
-        """
-        return False
-
-    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
-        """
-        return not self.is_operator()
-
-    @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)
-        """
-        return 0
-
-    @property
-    def left_associative(self) -> bool:
-        """Indicates whether this operator is left-associative.
-
-        Returns:
-            True if left-associative, False otherwise
-        """
-        return False
-
-    def print(self) -> str:
-        """Prints a string representation of the AST tree starting from this node.
-
-        Returns:
-            A formatted string showing the tree structure
-        """
-        return '\n'.join(self._print(0))
-
-    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
-        """
-        if indent == 0:
-            yield self.__class__.__name__
-        elif indent > 0:
-            yield '-' * indent + f' {self}'
-        for child in self.children:
-            yield from child._print(indent + 1)
-
-    def __str__(self) -> str:
-        """Returns a string representation of this node. Override in subclasses for custom formatting.
-
-        Returns:
-            The string representation
-        """
-        return self.__class__.__name__