flowquery 1.0.46 → 1.0.48

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

@@ -1,143 +0,0 @@
-"""Graph node representation for FlowQuery."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Union
-
-from ..parsing.ast_node import ASTNode
-from ..parsing.expressions.expression import Expression
-from .node_data import NodeData, NodeRecord
-
-if TYPE_CHECKING:
-    from .relationship import Relationship
-
-
-class Node(ASTNode):
-    """Represents a node in a graph pattern."""
-
-    def __init__(
-        self,
-        identifier: Optional[str] = None,
-        label: Optional[str] = None
-    ):
-        super().__init__()
-        self._identifier = identifier
-        self._label = label
-        self._properties: Dict[str, Expression] = {}
-        self._value: Optional['NodeRecord'] = None
-        self._incoming: Optional['Relationship'] = None
-        self._outgoing: Optional['Relationship'] = None
-        self._data: Optional['NodeData'] = None
-        self._todo_next: Optional[Callable[[], Union[None, Awaitable[None]]]] = None
-
-    @property
-    def identifier(self) -> Optional[str]:
-        return self._identifier
-
-    @identifier.setter
-    def identifier(self, value: str) -> None:
-        self._identifier = value
-
-    @property
-    def label(self) -> Optional[str]:
-        return self._label
-
-    @label.setter
-    def label(self, value: Optional[str]) -> None:
-        self._label = value
-
-    @property
-    def properties(self) -> Dict[str, Expression]:
-        return self._properties
-
-    @properties.setter
-    def properties(self, value: Dict[str, Expression]) -> None:
-        self._properties = value
-
-    def set_property(self, key: str, value: Expression) -> None:
-        self._properties[key] = value
-
-    def get_property(self, key: str) -> Optional[Expression]:
-        return self._properties.get(key)
-
-    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 node data available")
-            if key not in record:
-                raise ValueError("Node does not have property")
-            return bool(record[key] == expression.value())
-        return True
-
-    def set_value(self, value: Optional[Dict[str, Any]]) -> None:
-        self._value = value  # type: ignore[assignment]
-
-    def value(self) -> Optional['NodeRecord']:
-        return self._value
-
-    @property
-    def outgoing(self) -> Optional['Relationship']:
-        return self._outgoing
-
-    @outgoing.setter
-    def outgoing(self, relationship: Optional['Relationship']) -> None:
-        self._outgoing = relationship
-
-    @property
-    def incoming(self) -> Optional['Relationship']:
-        return self._incoming
-
-    @incoming.setter
-    def incoming(self, relationship: Optional['Relationship']) -> None:
-        self._incoming = relationship
-
-    def set_data(self, data: Optional['NodeData']) -> None:
-        self._data = data
-
-    async def next(self) -> None:
-        if self._data:
-            self._data.reset()
-            while self._data.next():
-                current = self._data.current()
-                if current is not None:
-                    self.set_value(current)
-                    if not self._matches_properties():
-                        continue
-                    if self._outgoing and self._value:
-                        await self._outgoing.find(self._value['id'])
-                    await self.run_todo_next()
-
-    async def find(self, id_: str, hop: int = 0) -> None:
-        if self._data:
-            self._data.reset()
-            while self._data.find(id_, hop):
-                current = self._data.current(hop)
-                if current is not None:
-                    self.set_value(current)
-                    if not self._matches_properties(hop):
-                        continue
-                    if self._incoming:
-                        self._incoming.set_end_node(self)
-                    if self._outgoing and self._value:
-                        await self._outgoing.find(self._value['id'], hop)
-                    await self.run_todo_next()
-
-    @property
-    def todo_next(self) -> Optional[Callable[[], Union[None, Awaitable[None]]]]:
-        return self._todo_next
-
-    @todo_next.setter
-    def todo_next(self, func: Optional[Callable[[], Union[None, Awaitable[None]]]]) -> None:
-        self._todo_next = func
-
-    async def run_todo_next(self) -> None:
-        if self._todo_next:
-            result = self._todo_next()
-            if result is not None:
-                await result

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

@@ -1,26 +0,0 @@
-"""Node data class for FlowQuery."""
-
-from typing import Any, Dict, List, Optional, TypedDict
-
-from .data import Data
-
-
-class NodeRecord(TypedDict, total=False):
-    """Represents a node record from the database."""
-    id: str
-
-
-class NodeData(Data):
-    """Node data class extending Data with ID-based indexing."""
-
-    def __init__(self, records: Optional[List[Dict[str, Any]]] = None):
-        super().__init__(records)
-        self._build_index("id")
-
-    def find(self, id_: str, hop: int = 0) -> bool:
-        """Find a record by ID."""
-        return self._find(id_, hop, "id")
-
-    def current(self, hop: int = 0) -> Optional[Dict[str, Any]]:
-        """Get the current record."""
-        return super().current(hop)

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

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Optional
-
-from ..parsing.ast_node import ASTNode
-from .node import Node
-
-
-class NodeReference(Node):
-    """Represents a reference to an existing node variable."""
-
-    def __init__(self, base: Node, reference: ASTNode) -> None:
-        super().__init__(base.identifier, base.label)
-        self._reference: ASTNode = reference
-        # Copy properties from base
-        self._properties = base._properties
-        self._outgoing = base.outgoing
-        self._incoming = base.incoming
-
-    @property
-    def reference(self) -> ASTNode:
-        return self._reference
-
-    # Keep referred as alias for backward compatibility
-    @property
-    def referred(self) -> ASTNode:
-        return self._reference
-
-    def value(self) -> Optional[Any]:
-        return self._reference.value() if self._reference else None
-
-    async def next(self) -> None:
-        """Process next using the referenced node's value."""
-        ref_value = self._reference.value()
-        if ref_value is None:
-            return
-        self.set_value(dict(ref_value))
-        if self._outgoing and self._value:
-            await self._outgoing.find(self._value['id'])
-        await self.run_todo_next()
-
-    async def find(self, id_: str, hop: int = 0) -> None:
-        """Find by ID, only matching if it equals the referenced node's ID."""
-        referenced = self._reference.value()
-        if referenced is None or id_ != referenced.get('id'):
-            return
-        self.set_value(dict(referenced))
-        if self._outgoing and self._value:
-            await self._outgoing.find(self._value['id'], hop)
-        await self.run_todo_next()

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

@@ -1,115 +0,0 @@
-"""Graph pattern representation for FlowQuery."""
-
-from __future__ import annotations
-
-from typing import Any, Generator, List, Optional, Sequence, Union
-
-from ..parsing.ast_node import ASTNode
-from .database import Database
-from .node import Node
-from .node_data import NodeData
-from .relationship import Relationship
-from .relationship_data import RelationshipData
-
-
-class Pattern(ASTNode):
-    """Represents a graph pattern for matching."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._identifier: Optional[str] = None
-        self._chain: List[Union['Node', 'Relationship']] = []
-
-    @property
-    def identifier(self) -> Optional[str]:
-        return self._identifier
-
-    @identifier.setter
-    def identifier(self, value: str) -> None:
-        self._identifier = value
-
-    @property
-    def chain(self) -> List[Union['Node', 'Relationship']]:
-        return self._chain
-
-    @property
-    def elements(self) -> Sequence[ASTNode]:
-        return self._chain
-
-    def add_element(self, element: Union['Node', 'Relationship']) -> None:
-        if (len(self._chain) > 0 and
-            type(self._chain[-1]) is type(element)):
-            raise ValueError("Cannot add two consecutive elements of the same type to the graph pattern")
-
-        if len(self._chain) > 0:
-            last = self._chain[-1]
-            if isinstance(last, Node) and isinstance(element, Relationship):
-                last.outgoing = element
-                element.source = last
-            if isinstance(last, Relationship) and isinstance(element, Node):
-                last.target = element
-                element.incoming = last
-
-        self._chain.append(element)
-        self.add_child(element)
-
-    @property
-    def start_node(self) -> 'Node':
-        if len(self._chain) == 0:
-            raise ValueError("Pattern is empty")
-        first = self._chain[0]
-        if isinstance(first, Node):
-            return first
-        raise ValueError("Pattern does not start with a node")
-
-    @property
-    def end_node(self) -> 'Node':
-        if len(self._chain) == 0:
-            raise ValueError("Pattern is empty")
-        last = self._chain[-1]
-        if isinstance(last, Node):
-            return last
-        raise ValueError("Pattern does not end with a node")
-
-    def first_node(self) -> Optional[Union['Node', 'Relationship']]:
-        if len(self._chain) > 0:
-            return self._chain[0]
-        return None
-
-    def value(self) -> List[Any]:
-        return list(self.values())
-
-    def values(self) -> Generator[Any, None, None]:
-        for i, element in enumerate(self._chain):
-            if isinstance(element, Node):
-                # Skip node if previous element was a zero-hop relationship (no matches)
-                prev = self._chain[i-1] if i > 0 else None
-                if isinstance(prev, Relationship) and len(prev.matches) == 0:
-                    continue
-                yield element.value()
-            elif isinstance(element, Relationship):
-                for j, match in enumerate(element.matches):
-                    yield match
-                    if j < len(element.matches) - 1:
-                        yield match["endNode"]
-
-    async def fetch_data(self) -> None:
-        """Loads data from the database for all elements."""
-        db = Database.get_instance()
-        for element in self._chain:
-            # Use type name comparison to avoid issues with module double-loading
-            if type(element).__name__ in ('NodeReference', 'RelationshipReference'):
-                continue
-            data = await db.get_data(element)
-            if isinstance(element, Node) and isinstance(data, NodeData):
-                element.set_data(data)
-            elif isinstance(element, Relationship) and isinstance(data, RelationshipData):
-                element.set_data(data)
-
-    async def initialize(self) -> None:
-        await self.fetch_data()
-
-    async def traverse(self) -> None:
-        first = self.first_node()
-        if first and isinstance(first, Node):
-            await first.next()

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

@@ -1,67 +0,0 @@
-"""Pattern expression for FlowQuery."""
-
-from typing import Any, Union
-
-from ..parsing.ast_node import ASTNode
-from .node import Node
-from .node_reference import NodeReference
-from .pattern import Pattern
-from .relationship import Relationship
-
-
-class PatternExpression(Pattern):
-    """Represents a pattern expression that can be evaluated.
-
-    PatternExpression is used in WHERE clauses to test whether a graph pattern
-    exists. It evaluates to True if the pattern is matched, False otherwise.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._fetched: bool = False
-        self._evaluation: bool = False
-
-    def add_element(self, element: Union[Node, Relationship]) -> None:
-        super().add_element(element)
-
-    def verify(self) -> None:
-        if(len(self._chain) == 0):
-            raise ValueError("PatternExpression cannot be empty")
-        if not(any(isinstance(el, NodeReference) for el in self._chain if isinstance(el, ASTNode))):
-            raise ValueError("PatternExpression must contain at least one NodeReference")
-
-    @property
-    def identifier(self) -> None:
-        return None
-
-    @identifier.setter
-    def identifier(self, value: str) -> None:
-        raise ValueError("Cannot set identifier on PatternExpression")
-
-    async def fetch_data(self) -> None:
-        """Fetches data for the pattern expression with caching."""
-        if self._fetched:
-            return
-        await super().fetch_data()
-        self._fetched = True
-
-    async def evaluate(self) -> None:
-        """Evaluates the pattern expression by traversing the graph.
-
-        Sets _evaluation to True if the pattern is matched, False otherwise.
-        """
-        self._evaluation = False
-
-        async def set_evaluation_true() -> None:
-            self._evaluation = True
-
-        self.end_node.todo_next = set_evaluation_true
-        await self.start_node.next()
-
-    def value(self) -> Any:
-        """Returns the result of the pattern evaluation."""
-        return self._evaluation
-
-    def is_operand(self) -> bool:
-        """PatternExpression is an operand in expressions."""
-        return True

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

@@ -1,42 +0,0 @@
-"""Collection of graph patterns for FlowQuery."""
-
-from typing import Awaitable, Callable, List, Optional
-
-from .pattern import Pattern
-
-
-class Patterns:
-    """Manages a collection of graph patterns."""
-
-    def __init__(self, patterns: Optional[List[Pattern]] = None) -> None:
-        self._patterns = patterns or []
-        self._to_do_next: Optional[Callable[[], Awaitable[None]]] = None
-
-    @property
-    def patterns(self) -> List[Pattern]:
-        return self._patterns
-
-    @property
-    def to_do_next(self) -> Optional[Callable[[], Awaitable[None]]]:
-        return self._to_do_next
-
-    @to_do_next.setter
-    def to_do_next(self, func: Optional[Callable[[], Awaitable[None]]]) -> None:
-        self._to_do_next = func
-        if self._patterns:
-            self._patterns[-1].end_node.todo_next = func
-
-    async def initialize(self) -> None:
-        previous: Optional[Pattern] = None
-        for pattern in self._patterns:
-            await pattern.fetch_data()  # Ensure data is loaded
-            if previous is not None:
-                # Chain the patterns together
-                async def next_pattern_start(p: Pattern = pattern) -> None:
-                    await p.start_node.next()
-                previous.end_node.todo_next = next_pattern_start
-            previous = pattern
-
-    async def traverse(self) -> None:
-        if self._patterns:
-            await self._patterns[0].start_node.next()

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

@@ -1,41 +0,0 @@
-"""Physical node representation for FlowQuery."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from ..parsing.ast_node import ASTNode
-from .node import Node
-
-
-class PhysicalNode(Node):
-    """Represents a physical node in the graph database."""
-
-    def __init__(self, id_: Optional[str], label: str, properties: Optional[Dict[str, Any]] = None):
-        super().__init__(id_, label)
-        # Store additional physical properties in a separate dict
-        # (Node.properties is for Expression-based pattern properties)
-        self._physical_properties = properties or {}
-        self._statement: Optional["ASTNode"] = None
-
-    @property
-    def physical_properties(self) -> Dict[str, Any]:
-        """Get the physical properties (values, not expressions)."""
-        return self._physical_properties
-
-    @property
-    def statement(self) -> Optional["ASTNode"]:
-        return self._statement
-
-    @statement.setter
-    def statement(self, value: Optional["ASTNode"]) -> None:
-        self._statement = value
-
-    async def data(self) -> List[Dict[str, Any]]:
-        if self._statement is None:
-            raise ValueError("Statement is null")
-        # Import at runtime to avoid circular dependency
-        from ..compute.runner import Runner
-        runner = Runner(ast=self._statement)
-        await runner.run()
-        return runner.results

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

@@ -1,36 +0,0 @@
-"""Physical relationship representation for FlowQuery."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from ..parsing.ast_node import ASTNode
-from .relationship import Relationship
-
-
-class PhysicalRelationship(Relationship):
-    """Represents a physical relationship in the graph database."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._statement: Optional[ASTNode] = None
-
-    @property
-    def statement(self) -> Optional[ASTNode]:
-        """Get the statement for this relationship."""
-        return self._statement
-
-    @statement.setter
-    def statement(self, value: Optional[ASTNode]) -> None:
-        """Set the statement for this relationship."""
-        self._statement = value
-
-    async def data(self) -> List[Dict[str, Any]]:
-        """Execute the statement and return results."""
-        if self._statement is None:
-            raise ValueError("Statement is null")
-        # Import at runtime to avoid circular dependency
-        from ..compute.runner import Runner
-        runner = Runner(None, self._statement)
-        await runner.run()
-        return runner.results