flowquery 1.0.18 → 1.0.21

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

@@ -1,18 +1,21 @@
 """Graph pattern representation for FlowQuery."""
 
-from typing import Any, Generator, List, Optional, TYPE_CHECKING, Union
+from __future__ import annotations
 
-from ..parsing.ast_node import ASTNode
+from typing import Any, Generator, List, Optional, Sequence, Union
 
-if TYPE_CHECKING:
-    from .node import Node
-    from .relationship import Relationship
+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):
+    def __init__(self) -> None:
         super().__init__()
         self._identifier: Optional[str] = None
         self._chain: List[Union['Node', 'Relationship']] = []
@@ -30,17 +33,14 @@ class Pattern(ASTNode):
         return self._chain
 
     @property
-    def elements(self) -> List[ASTNode]:
+    def elements(self) -> Sequence[ASTNode]:
         return self._chain
 
     def add_element(self, element: Union['Node', 'Relationship']) -> None:
-        from .node import Node
-        from .relationship import Relationship
-        
-        if (len(self._chain) > 0 and 
-            type(self._chain[-1]) == type(element)):
+        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):
@@ -49,13 +49,12 @@ class Pattern(ASTNode):
             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':
-        from .node import Node
         if len(self._chain) == 0:
             raise ValueError("Pattern is empty")
         first = self._chain[0]
@@ -65,7 +64,6 @@ class Pattern(ASTNode):
 
     @property
     def end_node(self) -> 'Node':
-        from .node import Node
         if len(self._chain) == 0:
             raise ValueError("Pattern is empty")
         last = self._chain[-1]
@@ -73,7 +71,7 @@ class Pattern(ASTNode):
             return last
         raise ValueError("Pattern does not end with a node")
 
-    def first_node(self) -> Optional['Node']:
+    def first_node(self) -> Optional[Union['Node', 'Relationship']]:
         if len(self._chain) > 0:
             return self._chain[0]
         return None
@@ -82,38 +80,30 @@ class Pattern(ASTNode):
         return list(self.values())
 
     def values(self) -> Generator[Any, None, None]:
-        from .node import Node
-        from .relationship import Relationship
-        
-        for element in self._chain:
+        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):
-                i = 0
-                for match in element.matches:
+                for j, match in enumerate(element.matches):
                     yield match
-                    if i < len(element.matches) - 1:
+                    if j < len(element.matches) - 1:
                         yield match["endNode"]
-                    i += 1
 
     async def fetch_data(self) -> None:
         """Loads data from the database for all elements."""
-        from .database import Database
-        from .node import Node
-        from .relationship import Relationship
-        from .node_reference import NodeReference
-        from .relationship_reference import RelationshipReference
-        from .node_data import NodeData
-        from .relationship_data import RelationshipData
-        
         db = Database.get_instance()
         for element in self._chain:
-            if isinstance(element, (NodeReference, RelationshipReference)):
+            # 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):
+            if isinstance(element, Node) and isinstance(data, NodeData):
                 element.set_data(data)
-            elif isinstance(element, Relationship):
+            elif isinstance(element, Relationship) and isinstance(data, RelationshipData):
                 element.set_data(data)
 
     async def initialize(self) -> None:
@@ -121,5 +111,5 @@ class Pattern(ASTNode):
 
     async def traverse(self) -> None:
         first = self.first_node()
-        if first:
+        if first and isinstance(first, Node):
             await first.next()

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

@@ -1,25 +1,27 @@
 """Pattern expression for FlowQuery."""
 
-from typing import Any
+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):
+    def __init__(self) -> None:
         super().__init__()
         self._fetched: bool = False
         self._evaluation: bool = False
 
-    def add_element(self, element) -> None:
+    def add_element(self, element: Union[Node, Relationship]) -> None:
         super().add_element(element)
 
     def verify(self) -> None:
@@ -29,11 +31,11 @@ class PatternExpression(Pattern):
             raise ValueError("PatternExpression must contain at least one NodeReference")
 
     @property
-    def identifier(self):
+    def identifier(self) -> None:
         return None
 
     @identifier.setter
-    def identifier(self, value):
+    def identifier(self, value: str) -> None:
         raise ValueError("Cannot set identifier on PatternExpression")
 
     async def fetch_data(self) -> None:
@@ -45,18 +47,18 @@ class PatternExpression(Pattern):
 
     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():
+
+        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) -> bool:
+    def value(self) -> Any:
         """Returns the result of the pattern evaluation."""
         return self._evaluation
 

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

@@ -8,7 +8,7 @@ from .pattern import Pattern
 class Patterns:
     """Manages a collection of graph patterns."""
 
-    def __init__(self, patterns: Optional[List[Pattern]] = None):
+    def __init__(self, patterns: Optional[List[Pattern]] = None) -> None:
         self._patterns = patterns or []
         self._to_do_next: Optional[Callable[[], Awaitable[None]]] = None
 
@@ -32,7 +32,7 @@ class 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):
+                async def next_pattern_start(p: Pattern = pattern) -> None:
                     await p.start_node.next()
                 previous.end_node.todo_next = next_pattern_start
             previous = pattern

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

@@ -1,10 +1,10 @@
 """Physical node representation for FlowQuery."""
 
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from __future__ import annotations
 
-if TYPE_CHECKING:
-    from ..parsing.ast_node import ASTNode
+from typing import Any, Dict, List, Optional
 
+from ..parsing.ast_node import ASTNode
 from .node import Node
 
 
@@ -34,6 +34,7 @@ class PhysicalNode(Node):
     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()

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

@@ -1,18 +1,17 @@
 """Physical relationship representation for FlowQuery."""
 
 from __future__ import annotations
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
-from .relationship import Relationship
+from typing import Any, Dict, List, Optional
 
-if TYPE_CHECKING:
-    from ..parsing.ast_node import ASTNode
+from ..parsing.ast_node import ASTNode
+from .relationship import Relationship
 
 
 class PhysicalRelationship(Relationship):
     """Represents a physical relationship in the graph database."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self._statement: Optional[ASTNode] = None
 
@@ -30,6 +29,7 @@ class PhysicalRelationship(Relationship):
         """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()

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

@@ -1,26 +1,29 @@
 """Graph relationship representation for FlowQuery."""
 
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union
+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
-    from .relationship_data import RelationshipData, RelationshipRecord
 
 
 class Relationship(ASTNode):
     """Represents a relationship in a graph pattern."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self._identifier: Optional[str] = None
         self._type: Optional[str] = None
         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()
@@ -52,10 +55,26 @@ class Relationship(ASTNode):
 
     @property
     def properties(self) -> Dict[str, Any]:
-        """Get properties from relationship data."""
-        if self._data:
-            return self._data.properties() or {}
-        return {}
+        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']:
@@ -73,6 +92,14 @@ class Relationship(ASTNode):
     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']:
@@ -93,6 +120,9 @@ class Relationship(ASTNode):
     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') -> None:
         """Set value by pushing match to collector."""
         self._matches.push(relationship)
@@ -113,23 +143,41 @@ class Relationship(ASTNode):
         """Find relationships starting from the given node ID."""
         # Save original source node
         original = self._source
+        is_left = self._direction == "left"
         if hop > 0:
             # For hops greater than 0, the source becomes the target of the previous hop
             self._source = self._target
         if hop == 0:
-            self._data.reset() if self._data else None
-        
-        while self._data and self._data.find(left_id, hop):
+            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)
+
+        def find_match(id_: str, h: int) -> bool:
+            if self._data is None:
+                return False
+            if is_left:
+                return self._data.find_reverse(id_, h)
+            return self._data.find(id_, h)
+        follow_id = 'left_id' if is_left else 'right_id'
+        while self._data and find_match(left_id, hop):
             data = self._data.current(hop)
             if data and self._hops and hop >= self._hops.min:
                 self.set_value(self)
-                if self._target and 'right_id' in data:
-                    await self._target.find(data['right_id'], hop)
+                if not self._matches_properties(hop):
+                    continue
+                if self._target and follow_id in data:
+                    await self._target.find(data[follow_id], hop)
                 if self._matches.is_circular():
                     raise ValueError("Circular relationship detected")
                 if self._hops and hop + 1 < self._hops.max:
-                    await self.find(data['right_id'], hop + 1)
+                    await self.find(data[follow_id], hop + 1)
                 self._matches.pop()
-        
+
         # Restore original source node
         self._source = original

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

@@ -12,15 +12,20 @@ class RelationshipRecord(TypedDict, total=False):
 
 
 class RelationshipData(Data):
-    """Relationship data class extending Data with left_id-based indexing."""
+    """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, left_id: str, hop: int = 0) -> bool:
         """Find a relationship by start node ID."""
-        return self._find(left_id, hop)
+        return self._find(left_id, hop, "left_id")
+
+    def find_reverse(self, right_id: str, hop: int = 0) -> bool:
+        """Find a relationship by end node ID (reverse direction)."""
+        return self._find(right_id, hop, "right_id")
 
     def properties(self) -> Optional[Dict[str, Any]]:
         """Get properties of current relationship, excluding left_id and right_id."""

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

@@ -1,43 +1,47 @@
 """Collector for relationship match records."""
 
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, TypedDict, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict, Union
 
 if TYPE_CHECKING:
-    from .relationship import Relationship
     from .node import Node
+    from .relationship import Relationship
 
 
 class RelationshipMatchRecord(TypedDict, total=False):
     """Represents a matched relationship record."""
     type: str
-    startNode: Dict[str, Any]
-    endNode: Optional[Dict[str, Any]]
+    startNode: Any
+    endNode: Any
     properties: Dict[str, Any]
 
 
 class RelationshipMatchCollector:
     """Collects relationship matches during graph traversal."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._matches: List[RelationshipMatchRecord] = []
         self._node_ids: List[str] = []
 
     def push(self, relationship: 'Relationship') -> RelationshipMatchRecord:
         """Push a new match onto the collector."""
+        start_node_value = relationship.source.value() if relationship.source else None
+        rel_data = relationship.get_data()
+        rel_props: Dict[str, Any] = (rel_data.properties() or {}) if rel_data else {}
         match: RelationshipMatchRecord = {
             "type": relationship.type or "",
-            "startNode": relationship.source.value() if relationship.source else {},
+            "startNode": start_node_value or {},
             "endNode": None,
-            "properties": relationship.properties,
+            "properties": rel_props,
         }
         self._matches.append(match)
-        start_node_value = match.get("startNode", {})
         if isinstance(start_node_value, dict):
             self._node_ids.append(start_node_value.get("id", ""))
         return match
 
     @property
-    def end_node(self) -> Optional[Dict[str, Any]]:
+    def end_node(self) -> Any:
         """Get the end node of the last match."""
         if self._matches:
             return self._matches[-1].get("endNode")
@@ -47,7 +51,8 @@ class RelationshipMatchCollector:
     def end_node(self, node: 'Node') -> None:
         """Set the end node of the last match."""
         if self._matches:
-            self._matches[-1]["endNode"] = node.value()
+            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."""

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

@@ -1,13 +1,13 @@
-"""Relationship reference for FlowQuery."""
+from typing import Any, Optional
 
-from .relationship import Relationship
 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):
+    def __init__(self, relationship: Relationship, referred: ASTNode) -> None:
         super().__init__()
         self._referred = referred
         if relationship.type:
@@ -17,5 +17,5 @@ class RelationshipReference(Relationship):
     def referred(self) -> ASTNode:
         return self._referred
 
-    def value(self):
+    def value(self) -> Optional[Any]:
         return self._referred.value() if self._referred else None

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

@@ -2,34 +2,33 @@
 
 import argparse
 import asyncio
-from typing import Optional
 
 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))
@@ -38,13 +37,13 @@ class CommandLine:
 
     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 = []
@@ -61,13 +60,13 @@ class CommandLine:
                     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))
@@ -83,7 +82,7 @@ class CommandLine:
 
 def main() -> None:
     """Entry point for the flowquery CLI command.
-    
+
     Usage:
         flowquery              # Start interactive mode
         flowquery -c "query"   # Execute a single query
@@ -99,10 +98,10 @@ def main() -> None:
         metavar="QUERY",
         help="Execute a FlowQuery statement and exit"
     )
-    
+
     args = parser.parse_args()
     cli = CommandLine()
-    
+
     if args.command:
         cli.execute(args.command)
     else:

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

@@ -1,10 +1,10 @@
 """Parsing module for FlowQuery."""
 
-from .ast_node import ASTNode
-from .context import Context
 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__ = [

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

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