flowquery 1.0.18 → 1.0.21

package/flowquery-py/src/parsing/expressions/operator.py

@@ -39,7 +39,7 @@ class Operator(ASTNode, ABC):
 
 
 class Add(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(1, True)
 
     def value(self) -> Any:
@@ -47,7 +47,7 @@ class Add(Operator):
 
 
 class Subtract(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(1, True)
 
     def value(self) -> Any:
@@ -55,7 +55,7 @@ class Subtract(Operator):
 
 
 class Multiply(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(2, True)
 
     def value(self) -> Any:
@@ -63,7 +63,7 @@ class Multiply(Operator):
 
 
 class Divide(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(2, True)
 
     def value(self) -> Any:
@@ -71,7 +71,7 @@ class Divide(Operator):
 
 
 class Modulo(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(2, True)
 
     def value(self) -> Any:
@@ -79,7 +79,7 @@ class Modulo(Operator):
 
 
 class Power(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(3, False)
 
     def value(self) -> Any:
@@ -87,7 +87,7 @@ class Power(Operator):
 
 
 class Equals(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def value(self) -> int:
@@ -95,7 +95,7 @@ class Equals(Operator):
 
 
 class NotEquals(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def value(self) -> int:
@@ -103,7 +103,7 @@ class NotEquals(Operator):
 
 
 class GreaterThan(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def value(self) -> int:
@@ -111,7 +111,7 @@ class GreaterThan(Operator):
 
 
 class LessThan(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def value(self) -> int:
@@ -119,7 +119,7 @@ class LessThan(Operator):
 
 
 class GreaterThanOrEqual(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def value(self) -> int:
@@ -127,7 +127,7 @@ class GreaterThanOrEqual(Operator):
 
 
 class LessThanOrEqual(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def value(self) -> int:
@@ -135,7 +135,7 @@ class LessThanOrEqual(Operator):
 
 
 class And(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(-1, True)
 
     def value(self) -> int:
@@ -143,7 +143,7 @@ class And(Operator):
 
 
 class Or(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(-1, True)
 
     def value(self) -> int:
@@ -151,7 +151,7 @@ class Or(Operator):
 
 
 class Not(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(0, True)
 
     def is_operator(self) -> bool:
@@ -162,7 +162,7 @@ class Not(Operator):
 
 
 class Is(Operator):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(-1, True)
 
     def value(self) -> int:

package/flowquery-py/src/parsing/expressions/reference.py

@@ -8,9 +8,9 @@ from .identifier import Identifier
 
 class Reference(Identifier):
     """Represents a reference to a previously defined variable or expression.
-    
+
     References point to values defined earlier in the query (e.g., in WITH or LOAD statements).
-    
+
     Example:
         ref = Reference("myVar", previous_node)
         print(ref.value())  # Gets value from referred node
@@ -18,7 +18,7 @@ class Reference(Identifier):
 
     def __init__(self, value: str, referred: Optional[ASTNode] = None):
         """Creates a new Reference to a variable.
-        
+
         Args:
             value: The identifier name
             referred: The node this reference points to (optional)

package/flowquery-py/src/parsing/expressions/string.py

@@ -5,7 +5,7 @@ from ..ast_node import ASTNode
 
 class String(ASTNode):
     """Represents a string literal in the AST.
-    
+
     Example:
         s = String("hello")
         print(s.value())  # "hello"
@@ -13,7 +13,7 @@ class String(ASTNode):
 
     def __init__(self, value: str):
         """Creates a new String node with the given value.
-        
+
         Args:
             value: The string value
         """

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

@@ -1,41 +1,41 @@
 """Functions module for FlowQuery parsing."""
 
-from .function import Function
 from .aggregate_function import AggregateFunction
 from .async_function import AsyncFunction
-from .predicate_function import PredicateFunction
-from .reducer_element import ReducerElement
-from .value_holder import ValueHolder
+from .avg import Avg
+from .collect import Collect
+from .function import Function
+from .function_factory import FunctionFactory
 from .function_metadata import (
     FunctionCategory,
-    ParameterSchema,
-    OutputSchema,
-    FunctionMetadata,
     FunctionDef,
     FunctionDefOptions,
-    get_registered_function_metadata,
-    get_registered_function_factory,
+    FunctionMetadata,
+    OutputSchema,
+    ParameterSchema,
     get_function_metadata,
+    get_registered_function_factory,
+    get_registered_function_metadata,
 )
-from .function_factory import FunctionFactory
-
-# Built-in functions
-from .sum import Sum
-from .avg import Avg
-from .collect import Collect
+from .functions import Functions
 from .join import Join
 from .keys import Keys
+from .predicate_function import PredicateFunction
+from .predicate_sum import PredicateSum
 from .rand import Rand
 from .range_ import Range
+from .reducer_element import ReducerElement
 from .replace import Replace
 from .round_ import Round
 from .size import Size
 from .split import Split
 from .stringify import Stringify
+
+# Built-in functions
+from .sum import Sum
 from .to_json import ToJson
 from .type_ import Type
-from .functions import Functions
-from .predicate_sum import PredicateSum
+from .value_holder import ValueHolder
 
 __all__ = [
     # Base classes

package/flowquery-py/src/parsing/functions/aggregate_function.py

@@ -8,10 +8,10 @@ from .reducer_element import ReducerElement
 
 class AggregateFunction(Function):
     """Base class for aggregate functions that reduce multiple values to a single value.
-    
+
     Aggregate functions like SUM, AVG, and COLLECT process multiple input values
     and produce a single output. They cannot be nested within other aggregate functions.
-    
+
     Example:
         sum_func = Sum()
         # Used in: RETURN SUM(values)
@@ -19,19 +19,19 @@ class AggregateFunction(Function):
 
     def __init__(self, name: Optional[str] = None):
         """Creates a new AggregateFunction with the given name.
-        
+
         Args:
             name: The function name
         """
         super().__init__(name)
         self._overridden: Any = None
 
-    def reduce(self, value: ReducerElement) -> None:
+    def reduce(self, value: Any) -> None:
         """Processes a value during the aggregation phase.
-        
+
         Args:
             value: The element to aggregate
-            
+
         Raises:
             NotImplementedError: If not implemented by subclass
         """
@@ -39,10 +39,10 @@ class AggregateFunction(Function):
 
     def element(self) -> ReducerElement:
         """Creates a reducer element for this aggregate function.
-        
+
         Returns:
             A ReducerElement instance
-            
+
         Raises:
             NotImplementedError: If not implemented by subclass
         """

package/flowquery-py/src/parsing/functions/async_function.py

@@ -8,10 +8,10 @@ from .function import Function
 
 class AsyncFunction(Function):
     """Represents an async data provider function call for use in LOAD operations.
-    
+
     This class holds the function name and arguments, and provides async iteration
     over the results from a registered async data provider.
-    
+
     Example:
         # Used in: LOAD JSON FROM myDataSource('arg1', 'arg2') AS data
         async_func = AsyncFunction("myDataSource")
@@ -27,7 +27,7 @@ class AsyncFunction(Function):
     @parameters.setter
     def parameters(self, nodes: List[ASTNode]) -> None:
         """Sets the function parameters.
-        
+
         Args:
             nodes: Array of AST nodes representing the function arguments
         """
@@ -36,7 +36,7 @@ class AsyncFunction(Function):
     def get_arguments(self) -> List[Any]:
         """Evaluates all parameters and returns their values.
         Used by the framework to pass arguments to generate().
-        
+
         Returns:
             Array of parameter values
         """
@@ -44,19 +44,22 @@ class AsyncFunction(Function):
 
     async def generate(self, *args: Any) -> AsyncGenerator[Any, None]:
         """Generates the async data provider function results.
-        
+
         Subclasses override this method with their own typed parameters.
         The framework automatically evaluates the AST children and spreads
         them as arguments when calling this method.
-        
+
         Args:
             args: Arguments passed from the query (e.g., myFunc(arg1, arg2))
-            
+
         Yields:
             Data items from the async provider
-            
+
         Raises:
             NotImplementedError: If the function is not registered as an async provider
         """
         raise NotImplementedError("generate method must be overridden in subclasses.")
-        yield  # Make this a generator
+        # Note: yield is here only to make this a generator function
+        # It will never be reached due to the raise above
+        if False:  # pragma: no cover
+            yield  # Make this a generator

package/flowquery-py/src/parsing/functions/avg.py

@@ -3,14 +3,14 @@
 from typing import Optional
 
 from .aggregate_function import AggregateFunction
-from .reducer_element import ReducerElement
 from .function_metadata import FunctionDef
+from .reducer_element import ReducerElement
 
 
 class AvgReducerElement(ReducerElement):
     """Reducer element for Avg aggregate function."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._count: int = 0
         self._sum: Optional[float] = None
 
@@ -40,11 +40,11 @@ class AvgReducerElement(ReducerElement):
 })
 class Avg(AggregateFunction):
     """Avg aggregate function.
-    
+
     Calculates the average of numeric values across grouped rows.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("avg")
         self._expected_parameter_count = 1
 

package/flowquery-py/src/parsing/functions/collect.py

@@ -1,17 +1,17 @@
 """Collect aggregate function."""
 
-from typing import Any, Dict, List, Union
 import json
+from typing import Any, Dict, List, Union
 
 from .aggregate_function import AggregateFunction
-from .reducer_element import ReducerElement
 from .function_metadata import FunctionDef
+from .reducer_element import ReducerElement
 
 
 class CollectReducerElement(ReducerElement):
     """Reducer element for Collect aggregate function."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._value: List[Any] = []
 
     @property
@@ -26,7 +26,7 @@ class CollectReducerElement(ReducerElement):
 class DistinctCollectReducerElement(ReducerElement):
     """Reducer element for Collect aggregate function with DISTINCT."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._value: Dict[str, Any] = {}
 
     @property
@@ -51,11 +51,11 @@ class DistinctCollectReducerElement(ReducerElement):
 })
 class Collect(AggregateFunction):
     """Collect aggregate function.
-    
+
     Collects values into an array across grouped rows.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("collect")
         self._expected_parameter_count = 1
         self._distinct: bool = False

package/flowquery-py/src/parsing/functions/function.py

@@ -1,16 +1,16 @@
 """Base class for all functions in FlowQuery."""
 
-from typing import List, Optional, Any
+from typing import List, Optional
 
 from ..ast_node import ASTNode
 
 
 class Function(ASTNode):
     """Base class for all functions in FlowQuery.
-    
+
     Functions can have parameters and may support the DISTINCT modifier.
     Subclasses implement specific function logic.
-    
+
     Example:
         func = FunctionFactory.create("sum")
         func.parameters = [expression1, expression2]
@@ -18,7 +18,7 @@ class Function(ASTNode):
 
     def __init__(self, name: Optional[str] = None):
         """Creates a new Function with the given name.
-        
+
         Args:
             name: The function name
         """
@@ -35,10 +35,10 @@ class Function(ASTNode):
     @parameters.setter
     def parameters(self, nodes: List[ASTNode]) -> None:
         """Sets the function parameters.
-        
+
         Args:
             nodes: Array of AST nodes representing the function arguments
-            
+
         Raises:
             ValueError: If the number of parameters doesn't match expected count
         """

package/flowquery-py/src/parsing/functions/function_factory.py

@@ -2,9 +2,6 @@
 
 from typing import Any, Callable, Dict, List, Optional
 
-from .function import Function
-from .async_function import AsyncFunction
-from .predicate_function import PredicateFunction
 from .function_metadata import (
     FunctionMetadata,
     get_function_metadata,
@@ -15,23 +12,23 @@ from .function_metadata import (
 
 class FunctionFactory:
     """Factory for creating function instances by name.
-    
+
     All functions are registered via the @FunctionDef decorator.
     Maps function names (case-insensitive) to their corresponding implementation classes.
     Supports built-in functions like sum, avg, collect, range, split, join, etc.
-    
+
     Example:
         sum_func = FunctionFactory.create("sum")
         avg_func = FunctionFactory.create("AVG")
     """
 
     @staticmethod
-    def get_async_provider(name: str) -> Optional[Callable]:
+    def get_async_provider(name: str) -> Optional[Callable[..., Any]]:
         """Gets an async data provider by name.
-        
+
         Args:
             name: The function name (case-insensitive)
-            
+
         Returns:
             The async data provider, or None if not found
         """
@@ -40,10 +37,10 @@ class FunctionFactory:
     @staticmethod
     def is_async_provider(name: str) -> bool:
         """Checks if a function name is registered as an async data provider.
-        
+
         Args:
             name: The function name (case-insensitive)
-            
+
         Returns:
             True if the function is an async data provider
         """
@@ -52,10 +49,10 @@ class FunctionFactory:
     @staticmethod
     def get_metadata(name: str) -> Optional[FunctionMetadata]:
         """Gets metadata for a specific function.
-        
+
         Args:
             name: The function name (case-insensitive)
-            
+
         Returns:
             The function metadata, or None if not found
         """
@@ -68,17 +65,17 @@ class FunctionFactory:
         sync_only: bool = False
     ) -> List[FunctionMetadata]:
         """Lists all registered functions with their metadata.
-        
+
         Args:
             category: Optional category filter
             async_only: If True, only return async functions
             sync_only: If True, only return sync functions
-            
+
         Returns:
             Array of function metadata
         """
         result: List[FunctionMetadata] = []
-        
+
         for meta in get_registered_function_metadata():
             if category and meta.category != category:
                 continue
@@ -87,13 +84,13 @@ class FunctionFactory:
             if sync_only and meta.category == "async":
                 continue
             result.append(meta)
-        
+
         return result
 
     @staticmethod
     def list_function_names() -> List[str]:
         """Lists all registered function names.
-        
+
         Returns:
             Array of function names
         """
@@ -102,7 +99,7 @@ class FunctionFactory:
     @staticmethod
     def to_json() -> Dict[str, Any]:
         """Gets all function metadata as a JSON-serializable object for LLM consumption.
-        
+
         Returns:
             Object with functions grouped by category
         """
@@ -111,58 +108,58 @@ class FunctionFactory:
         return {"functions": functions, "categories": categories}
 
     @staticmethod
-    def create(name: str) -> Function:
+    def create(name: str) -> Any:
         """Creates a function instance by name.
-        
+
         Args:
             name: The function name (case-insensitive)
-            
+
         Returns:
             A Function instance of the appropriate type
-            
+
         Raises:
             ValueError: If the function name is not registered
         """
         lower_name = name.lower()
-        
+
         # Check decorator-registered functions
         decorator_factory = get_registered_function_factory(lower_name)
         if decorator_factory:
             return decorator_factory()
-        
+
         raise ValueError(f"Unknown function: {name}")
 
     @staticmethod
-    def create_predicate(name: str) -> PredicateFunction:
+    def create_predicate(name: str) -> Any:
         """Creates a predicate function instance by name.
-        
+
         Args:
             name: The function name (case-insensitive)
-            
+
         Returns:
             A PredicateFunction instance of the appropriate type
-            
+
         Raises:
             ValueError: If the predicate function name is not registered
         """
         lower_name = name.lower()
-        
+
         decorator_factory = get_registered_function_factory(lower_name, "predicate")
         if decorator_factory:
             return decorator_factory()
-        
+
         raise ValueError(f"Unknown predicate function: {name}")
 
     @staticmethod
-    def create_async(name: str) -> AsyncFunction:
+    def create_async(name: str) -> Any:
         """Creates an async function instance by name.
-        
+
         Args:
             name: The function name (case-insensitive)
-            
+
         Returns:
             An AsyncFunction instance of the appropriate type
-            
+
         Raises:
             ValueError: If the async function name is not registered
         """