flowquery 1.0.20 → 1.0.21

package/flowquery-py/src/tokenization/tokenizer.py

@@ -1,6 +1,6 @@
 """Tokenizes FlowQuery input strings into a sequence of tokens."""
 
-from typing import List, Optional, Iterator, Callable
+from typing import Callable, Iterator, List, Optional
 
 from ..utils.string_utils import StringUtils
 from .keyword import Keyword
@@ -13,11 +13,11 @@ from .token_mapper import TokenMapper
 
 class Tokenizer:
     """Tokenizes FlowQuery input strings into a sequence of tokens.
-    
+
     The tokenizer performs lexical analysis, breaking down the input text into
     meaningful tokens such as keywords, identifiers, operators, strings, numbers,
     and symbols. It handles comments, whitespace, and f-strings.
-    
+
     Example:
         tokenizer = Tokenizer("WITH x = 1 RETURN x")
         tokens = tokenizer.tokenize()
@@ -25,7 +25,7 @@ class Tokenizer:
 
     def __init__(self, input_: str):
         """Creates a new Tokenizer instance for the given input.
-        
+
         Args:
             input_: The FlowQuery input string to tokenize
         """
@@ -36,16 +36,16 @@ class Tokenizer:
 
     def tokenize(self) -> List[Token]:
         """Tokenizes the input string into an array of tokens.
-        
+
         Returns:
             An array of Token objects representing the tokenized input
-            
+
         Raises:
             ValueError: If an unrecognized token is encountered
         """
         tokens: List[Token] = []
         last: Optional[Token] = None
-        
+
         while not self._walker.is_at_end:
             tokens.extend(self._f_string())
             last = self._get_last_non_whitespace_or_non_comment_token(tokens) or last
@@ -54,7 +54,7 @@ class Tokenizer:
                 raise ValueError(f"Unrecognized token at position {self._walker.position}")
             token.position = self._walker.position
             tokens.append(token)
-        
+
         return tokens
 
     def _get_last_non_whitespace_or_non_comment_token(self, tokens: List[Token]) -> Optional[Token]:
@@ -97,9 +97,9 @@ class Tokenizer:
     def _identifier(self) -> Optional[Token]:
         start_position = self._walker.position
         if self._walker.check_for_under_score() or self._walker.check_for_letter():
-            while (not self._walker.is_at_end and 
-                   (self._walker.check_for_letter() or 
-                    self._walker.check_for_digit() or 
+            while (not self._walker.is_at_end and
+                   (self._walker.check_for_letter() or
+                    self._walker.check_for_digit() or
                     self._walker.check_for_under_score())):
                 pass
             return Token.IDENTIFIER(self._walker.get_string(start_position))
@@ -110,7 +110,7 @@ class Tokenizer:
         quote_char = self._walker.check_for_quote()
         if quote_char is None:
             return None
-        
+
         while not self._walker.is_at_end:
             if self._walker.escaped(quote_char):
                 self._walker.move_next()
@@ -122,32 +122,32 @@ class Tokenizer:
                     return Token.BACKTICK_STRING(value, quote_char)
                 return Token.STRING(value, quote_char)
             self._walker.move_next()
-        
+
         raise ValueError(f"Unterminated string at position {start_position}")
 
     def _f_string(self) -> Iterator[Token]:
         if not self._walker.check_for_f_string_start():
             return
-        
+
         self._walker.move_next()  # skip the f
         position = self._walker.position
         quote_char = self._walker.check_for_quote()
         if quote_char is None:
             return
-        
+
         while not self._walker.is_at_end:
             if self._walker.escaped(quote_char) or self._walker.escaped_brace():
                 self._walker.move_next()
                 self._walker.move_next()
                 continue
-            
+
             if self._walker.opening_brace():
                 yield Token.F_STRING(self._walker.get_string(position), quote_char)
                 position = self._walker.position
                 yield Token.OPENING_BRACE()
                 self._walker.move_next()  # skip the opening brace
                 position = self._walker.position
-                
+
                 while not self._walker.is_at_end and not self._walker.closing_brace():
                     token = self._get_next_token()
                     if token is not None:
@@ -159,11 +159,11 @@ class Tokenizer:
                         self._walker.move_next()  # skip the closing brace
                         position = self._walker.position
                         break
-            
+
             if self._walker.check_for_string(quote_char):
                 yield Token.F_STRING(self._walker.get_string(position), quote_char)
                 return
-            
+
             self._walker.move_next()
 
     def _whitespace(self) -> Optional[Token]:

package/flowquery-py/src/tokenization/trie.py

@@ -1,6 +1,7 @@
 """Trie (prefix tree) data structure for efficient keyword and operator lookup."""
 
 from __future__ import annotations
+
 from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
@@ -9,12 +10,12 @@ if TYPE_CHECKING:
 
 class TrieNode:
     """Represents a node in a Trie data structure.
-    
+
     Each node can have children nodes (one per character) and may contain a token
     if the path to this node represents a complete word.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._children: dict[str, TrieNode] = {}
         self._token: Optional[Token] = None
 
@@ -43,59 +44,59 @@ class TrieNode:
 
 class Trie:
     """Trie (prefix tree) data structure for efficient keyword and operator lookup.
-    
+
     Used during tokenization to quickly match input strings against known keywords
     and operators. Supports case-insensitive matching and tracks the longest match found.
-    
+
     Example:
         trie = Trie()
         trie.insert(Token.WITH)
         found = trie.find("WITH")
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._root = TrieNode()
         self._max_length = 0
         self._last_found: Optional[str] = None
 
     def insert(self, token: Token) -> None:
         """Inserts a token into the trie.
-        
+
         Args:
             token: The token to insert
-            
+
         Raises:
             ValueError: If the token value is None or empty
         """
         if token.value is None or len(token.value) == 0:
             raise ValueError("Token value cannot be null or empty")
-        
+
         current_node = self._root
         for char in token.value:
             current_node = current_node.map(char.lower())
-        
+
         if len(token.value) > self._max_length:
             self._max_length = len(token.value)
-        
+
         current_node.token = token
 
     def find(self, value: str) -> Optional[Token]:
         """Finds a token by searching for the longest matching prefix in the trie.
-        
+
         Args:
             value: The string value to search for
-            
+
         Returns:
             The token if found, None otherwise
         """
         if len(value) == 0:
             return None
-        
+
         index = 0
         current: Optional[TrieNode] = None
         found: Optional[Token] = None
         self._last_found = None
-        
+
         while True:
             next_node = (current or self._root).retrieve(value[index].lower())
             if next_node is None:
@@ -107,17 +108,17 @@ class Trie:
             index += 1
             if index >= len(value) or index > self._max_length:
                 break
-        
+
         if current is not None and current.is_end_of_word():
             found = current.token
             self._last_found = value[:index]
-        
+
         return found
 
     @property
     def last_found(self) -> Optional[str]:
         """Gets the last matched string from the most recent find operation.
-        
+
         Returns:
             The last found string, or None if no match was found
         """

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

@@ -1,6 +1,6 @@
 """Utils module for FlowQuery."""
 
-from .string_utils import StringUtils
 from .object_utils import ObjectUtils
+from .string_utils import StringUtils
 
 __all__ = ["StringUtils", "ObjectUtils"]

package/flowquery-py/src/utils/object_utils.py

@@ -7,13 +7,13 @@ class ObjectUtils:
     """Utility class for object-related operations."""
 
     @staticmethod
-    def is_instance_of_any(obj: Any, classes: List[Type]) -> bool:
+    def is_instance_of_any(obj: Any, classes: List[Type[Any]]) -> bool:
         """Checks if an object is an instance of any of the provided classes.
-        
+
         Args:
             obj: The object to check
             classes: Array of class constructors to test against
-            
+
         Returns:
             True if the object is an instance of any class, False otherwise
         """

package/flowquery-py/src/utils/string_utils.py

@@ -3,11 +3,11 @@
 
 class StringUtils:
     """Utility class for string manipulation and validation.
-    
+
     Provides methods for handling quoted strings, comments, escape sequences,
     and identifier validation.
     """
-    
+
     quotes = ['"', "'", '`']
     letters = 'abcdefghijklmnopqrstuvwxyz'
     digits = '0123456789'
@@ -17,10 +17,10 @@ class StringUtils:
     @staticmethod
     def unquote(s: str) -> str:
         """Removes surrounding quotes from a string.
-        
+
         Args:
             s: The string to unquote
-            
+
         Returns:
             The unquoted string
         """
@@ -41,10 +41,10 @@ class StringUtils:
     @staticmethod
     def uncomment(s: str) -> str:
         """Removes comment markers from a string.
-        
+
         Args:
             s: The comment string
-            
+
         Returns:
             The string without comment markers
         """
@@ -59,11 +59,11 @@ class StringUtils:
     @staticmethod
     def remove_escaped_quotes(s: str, quote_char: str) -> str:
         """Removes escape sequences before quotes in a string.
-        
+
         Args:
             s: The string to process
             quote_char: The quote character that was escaped
-            
+
         Returns:
             The string with escape sequences removed
         """
@@ -79,10 +79,10 @@ class StringUtils:
     @staticmethod
     def remove_escaped_braces(s: str) -> str:
         """Removes escaped braces ({{ and }}) from f-strings.
-        
+
         Args:
             s: The string to process
-            
+
         Returns:
             The string with escaped braces resolved
         """
@@ -98,10 +98,10 @@ class StringUtils:
     @staticmethod
     def can_be_identifier(s: str) -> bool:
         """Checks if a string is a valid identifier.
-        
+
         Args:
             s: The string to validate
-            
+
         Returns:
             True if the string can be used as an identifier, false otherwise
         """

package/flowquery-py/tests/compute/test_runner.py

@@ -1335,4 +1335,208 @@ class TestRunner:
         results = match.results
         # With * meaning 0+ hops, Employee 1 (CEO) also matches itself (zero-hop)
         # Employee 1→1 (zero-hop), 2→1, 3→2→1, 4→2→1 = 4 results
-        assert len(results) == 4
+        assert len(results) == 4
+
+    @pytest.mark.asyncio
+    async def test_match_with_leftward_relationship_direction(self):
+        """Test match with leftward relationship direction."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirPerson) AS {
+                unwind [
+                    {id: 1, name: 'Person 1'},
+                    {id: 2, name: 'Person 2'},
+                    {id: 3, name: 'Person 3'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirPerson)-[:REPORTS_TO]-(:DirPerson) AS {
+                unwind [
+                    {left_id: 2, right_id: 1},
+                    {left_id: 3, right_id: 1}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        # Rightward: left_id -> right_id (2->1, 3->1)
+        right_match = Runner(
+            """
+            MATCH (a:DirPerson)-[:REPORTS_TO]->(b:DirPerson)
+            RETURN a.name AS employee, b.name AS manager
+            """
+        )
+        await right_match.run()
+        right_results = right_match.results
+        assert len(right_results) == 2
+        assert right_results[0] == {"employee": "Person 2", "manager": "Person 1"}
+        assert right_results[1] == {"employee": "Person 3", "manager": "Person 1"}
+
+        # Leftward: right_id -> left_id (1->2, 1->3) - reverse traversal
+        left_match = Runner(
+            """
+            MATCH (m:DirPerson)<-[:REPORTS_TO]-(e:DirPerson)
+            RETURN m.name AS manager, e.name AS employee
+            """
+        )
+        await left_match.run()
+        left_results = left_match.results
+        assert len(left_results) == 2
+        assert left_results[0] == {"manager": "Person 1", "employee": "Person 2"}
+        assert left_results[1] == {"manager": "Person 1", "employee": "Person 3"}
+
+    @pytest.mark.asyncio
+    async def test_match_with_leftward_direction_swapped_data(self):
+        """Test match with leftward direction produces same results as rightward with swapped data."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirCity) AS {
+                unwind [
+                    {id: 1, name: 'New York'},
+                    {id: 2, name: 'Boston'},
+                    {id: 3, name: 'Chicago'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirCity)-[:ROUTE]-(:DirCity) AS {
+                unwind [
+                    {left_id: 1, right_id: 2},
+                    {left_id: 1, right_id: 3}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        # Leftward from destination: find where right_id matches, follow left_id
+        match = Runner(
+            """
+            MATCH (dest:DirCity)<-[:ROUTE]-(origin:DirCity)
+            RETURN dest.name AS destination, origin.name AS origin
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 2
+        assert results[0] == {"destination": "Boston", "origin": "New York"}
+        assert results[1] == {"destination": "Chicago", "origin": "New York"}
+
+    @pytest.mark.asyncio
+    async def test_match_with_leftward_variable_length(self):
+        """Test match with leftward variable-length relationships."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirVarPerson) AS {
+                unwind [
+                    {id: 1, name: 'Person 1'},
+                    {id: 2, name: 'Person 2'},
+                    {id: 3, name: 'Person 3'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirVarPerson)-[:MANAGES]-(:DirVarPerson) AS {
+                unwind [
+                    {left_id: 1, right_id: 2},
+                    {left_id: 2, right_id: 3}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        # Leftward variable-length: traverse from right_id to left_id
+        match = Runner(
+            """
+            MATCH (a:DirVarPerson)<-[:MANAGES*]-(b:DirVarPerson)
+            RETURN a.name AS name1, b.name AS name2
+            """
+        )
+        await match.run()
+        results = match.results
+        # Leftward indexes on right_id. find(id) looks up right_id=id, follows left_id.
+        # Person 1: zero-hop only (no right_id=1)
+        # Person 2: zero-hop, then left_id=1 (1 hop)
+        # Person 3: zero-hop, then left_id=2 (1 hop), then left_id=1 (2 hops)
+        assert len(results) == 6
+        assert results[0] == {"name1": "Person 1", "name2": "Person 1"}
+        assert results[1] == {"name1": "Person 2", "name2": "Person 2"}
+        assert results[2] == {"name1": "Person 2", "name2": "Person 1"}
+        assert results[3] == {"name1": "Person 3", "name2": "Person 3"}
+        assert results[4] == {"name1": "Person 3", "name2": "Person 2"}
+        assert results[5] == {"name1": "Person 3", "name2": "Person 1"}
+
+    @pytest.mark.asyncio
+    async def test_match_with_leftward_double_graph_pattern(self):
+        """Test match with leftward double graph pattern."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirDoublePerson) AS {
+                unwind [
+                    {id: 1, name: 'Person 1'},
+                    {id: 2, name: 'Person 2'},
+                    {id: 3, name: 'Person 3'},
+                    {id: 4, name: 'Person 4'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:DirDoublePerson)-[:KNOWS]-(:DirDoublePerson) AS {
+                unwind [
+                    {left_id: 1, right_id: 2},
+                    {left_id: 2, right_id: 3},
+                    {left_id: 3, right_id: 4}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        # Leftward chain: (c)<-[:KNOWS]-(b)<-[:KNOWS]-(a)
+        match = Runner(
+            """
+            MATCH (c:DirDoublePerson)<-[:KNOWS]-(b:DirDoublePerson)<-[:KNOWS]-(a:DirDoublePerson)
+            RETURN a.name AS name1, b.name AS name2, c.name AS name3
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 2
+        assert results[0] == {"name1": "Person 1", "name2": "Person 2", "name3": "Person 3"}
+        assert results[1] == {"name1": "Person 2", "name2": "Person 3", "name3": "Person 4"}
+
+    async def test_match_with_constraints(self):
+        await Runner(
+            """
+            CREATE VIRTUAL (:ConstraintEmployee) AS {
+                unwind [
+                    {id: 1, name: 'Employee 1'},
+                    {id: 2, name: 'Employee 2'},
+                    {id: 3, name: 'Employee 3'},
+                    {id: 4, name: 'Employee 4'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            match (e:ConstraintEmployee{name:'Employee 1'})
+            return e.name as name
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 1
+        assert results[0]["name"] == "Employee 1"

package/flowquery-py/tests/parsing/test_parser.py

@@ -5,6 +5,9 @@ from typing import AsyncIterator
 from flowquery.parsing.parser import Parser
 from flowquery.parsing.functions.async_function import AsyncFunction
 from flowquery.parsing.functions.function_metadata import FunctionDef
+from flowquery.parsing.operations.match import Match
+from flowquery.graph.node import Node
+from flowquery.graph.relationship import Relationship
 
 
 # Test async function for CALL operation parsing test
@@ -678,3 +681,41 @@ class TestParser:
         parser = Parser()
         with pytest.raises(Exception, match="PatternExpression must contain at least one NodeReference"):
             parser.parse("MATCH (a:Person) WHERE (:Person)-[:KNOWS]->(:Person) RETURN a")
+
+    def test_node_with_properties(self):
+        """Test node with properties."""
+        parser = Parser()
+        ast = parser.parse("MATCH (a:Person{value: 'hello'}) return a")
+        expected = (
+            "ASTNode\n"
+            "- Match\n"
+            "- Return\n"
+            "-- Expression (a)\n"
+            "--- Reference (a)"
+        )
+        assert ast.print() == expected
+        match_op = ast.first_child()
+        assert isinstance(match_op, Match)
+        node = match_op.patterns[0].chain[0]
+        assert isinstance(node, Node)
+        assert node.properties.get("value") is not None
+        assert node.properties["value"].value() == "hello"
+
+    def test_relationship_with_properties(self):
+        """Test relationship with properties."""
+        parser = Parser()
+        ast = parser.parse("MATCH (:Person)-[r:LIKES{since: 2022}]->(:Food) return a")
+        expected = (
+            "ASTNode\n"
+            "- Match\n"
+            "- Return\n"
+            "-- Expression (a)\n"
+            "--- Reference (a)"
+        )
+        assert ast.print() == expected
+        match_op = ast.first_child()
+        assert isinstance(match_op, Match)
+        relationship = match_op.patterns[0].chain[1]
+        assert isinstance(relationship, Relationship)
+        assert relationship.properties.get("since") is not None
+        assert relationship.properties["since"].value() == 2022