flowquery 1.0.18 → 1.0.21

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

@@ -1,25 +1,24 @@
 """Represents a single token in the FlowQuery language."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Any
 
-from .token_type import TokenType
+from typing import Optional
+
+from ..parsing.ast_node import ASTNode
+from ..utils.string_utils import StringUtils
 from .keyword import Keyword
 from .operator import Operator
 from .symbol import Symbol
-from ..utils.string_utils import StringUtils
-
-if TYPE_CHECKING:
-    from ..parsing.ast_node import ASTNode
+from .token_type import TokenType
 
 
 class Token:
     """Represents a single token in the FlowQuery language.
-    
+
     Tokens are the atomic units of lexical analysis, produced by the tokenizer
     and consumed by the parser. Each token has a type (keyword, operator, identifier, etc.)
     and an optional value.
-    
+
     Example:
         with_token = Token.WITH()
         ident_token = Token.IDENTIFIER("myVar")
@@ -28,7 +27,7 @@ class Token:
 
     def __init__(self, type_: TokenType, value: Optional[str] = None):
         """Creates a new Token instance.
-        
+
         Args:
             type_: The type of the token
             value: The optional value associated with the token
@@ -41,10 +40,10 @@ class Token:
 
     def equals(self, other: Token) -> bool:
         """Checks if this token equals another token.
-        
+
         Args:
             other: The token to compare against
-            
+
         Returns:
             True if tokens are equal, False otherwise
         """
@@ -82,6 +81,7 @@ class Token:
 
     @property
     def node(self) -> ASTNode:
+        # Import at runtime to avoid circular dependency
         from ..parsing.token_to_node import TokenToNode
         return TokenToNode.convert(self)
 

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

@@ -1,6 +1,7 @@
 """Maps string values to tokens using a Trie for efficient lookup."""
 
-from typing import Optional
+from enum import Enum
+from typing import Optional, Type
 
 from .token import Token
 from .trie import Trie
@@ -8,24 +9,24 @@ from .trie import Trie
 
 class TokenMapper:
     """Maps string values to tokens using a Trie for efficient lookup.
-    
+
     Takes an enum of keywords, operators, or symbols and builds a trie
     for fast token matching during tokenization.
-    
+
     Example:
         mapper = TokenMapper(Keyword)
         token = mapper.map("WITH")
     """
 
-    def __init__(self, enum_class):
+    def __init__(self, enum_class: Type[Enum]) -> None:
         """Creates a TokenMapper from an enum of token values.
-        
+
         Args:
             enum_class: An enum class containing token values
         """
         self._trie = Trie()
         self._enum = enum_class
-        
+
         for member in enum_class:
             token = Token.method(member.name)
             if token is not None and token.value is not None:
@@ -33,10 +34,10 @@ class TokenMapper:
 
     def map(self, value: str) -> Optional[Token]:
         """Maps a string value to its corresponding token.
-        
+
         Args:
             value: The string value to map
-            
+
         Returns:
             The matched token, or None if no match found
         """
@@ -45,7 +46,7 @@ class TokenMapper:
     @property
     def last_found(self) -> Optional[str]:
         """Gets the last matched string from the most recent map operation.
-        
+
         Returns:
             The last found string, or None if no match
         """

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

@@ -5,7 +5,7 @@ from enum import Enum
 
 class TokenType(Enum):
     """Enumeration of all token types in FlowQuery."""
-    
+
     KEYWORD = "KEYWORD"
     BOOLEAN = "BOOLEAN"
     OPERATOR = "OPERATOR"

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
         """