flowquery 1.0.18 → 1.0.21

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

@@ -1,8 +1,7 @@
 """Function metadata and decorator for FlowQuery functions."""
 
-from typing import Any, Callable, Dict, List, Optional, TypedDict, Union
 from dataclasses import dataclass
-
+from typing import Any, Callable, Dict, List, Optional, TypedDict, cast
 
 # Type definitions
 FunctionCategory = str  # "scalar" | "aggregate" | "predicate" | "async" | string
@@ -54,7 +53,7 @@ class FunctionDefOptions(TypedDict, total=False):
 
 class FunctionRegistry:
     """Centralized registry for function metadata, factories, and async providers."""
-    
+
     _metadata: Dict[str, FunctionMetadata] = {}
     _factories: Dict[str, Callable[[], Any]] = {}
 
@@ -71,15 +70,15 @@ class FunctionRegistry:
             description=options.get('description', ''),
             category=options.get('category', 'scalar'),
             parameters=options.get('parameters', []),
-            output=options.get('output', {'description': '', 'type': 'any'}),
+            output=cast(OutputSchema, options.get('output', {'description': '', 'type': 'any'})),
             examples=options.get('examples'),
             notes=options.get('notes'),
         )
         cls._metadata[registry_key] = metadata
 
         if category != 'predicate':
-            cls._factories[display_name] = lambda c=constructor: c()
-        cls._factories[registry_key] = lambda c=constructor: c()
+            cls._factories[display_name] = lambda c=constructor: c()  # type: ignore[misc]
+        cls._factories[registry_key] = lambda c=constructor: c()  # type: ignore[misc]
 
     @classmethod
     def get_all_metadata(cls) -> List[FunctionMetadata]:
@@ -103,17 +102,17 @@ class FunctionRegistry:
         return cls._factories.get(lower_name)
 
 
-def FunctionDef(options: FunctionDefOptions):
+def FunctionDef(options: FunctionDefOptions) -> Callable[[type], type]:
     """Class decorator that registers function metadata.
-    
+
     The function name is derived from the class's constructor.
-    
+
     Args:
         options: Function metadata (excluding name)
-        
+
     Returns:
         Class decorator
-        
+
     Example:
         @FunctionDef({
             'description': "Adds two numbers",

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

@@ -1,6 +1,6 @@
 """Functions introspection function."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from .function import Function
 from .function_factory import FunctionFactory
@@ -8,10 +8,18 @@ from .function_metadata import FunctionDef
 
 
 @FunctionDef({
-    "description": "Lists all registered functions with their metadata. Useful for discovering available functions and their documentation.",
+    "description": (
+        "Lists all registered functions with their metadata. "
+        "Useful for discovering available functions and their documentation."
+    ),
     "category": "scalar",
     "parameters": [
-        {"name": "category", "description": "Optional category to filter by (e.g., 'aggregation', 'string', 'math')", "type": "string", "required": False}
+        {
+            "name": "category",
+            "description": "Optional category to filter by (e.g., 'aggregation', 'string', 'math')",
+            "type": "string",
+            "required": False
+        }
     ],
     "output": {
         "description": "Array of function metadata objects",
@@ -35,17 +43,17 @@ from .function_metadata import FunctionDef
 })
 class Functions(Function):
     """Functions introspection function.
-    
+
     Lists all registered functions with their metadata.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("functions")
         self._expected_parameter_count = None  # 0 or 1 parameter
 
     def value(self) -> Any:
         children = self.get_children()
-        
+
         if len(children) == 0:
             # Return all functions
             return FunctionFactory.list_functions()

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

@@ -2,9 +2,9 @@
 
 from typing import Any, List
 
-from .function import Function
 from ..ast_node import ASTNode
 from ..expressions.string import String
+from .function import Function
 from .function_metadata import FunctionDef
 
 
@@ -20,11 +20,11 @@ from .function_metadata import FunctionDef
 })
 class Join(Function):
     """Join function.
-    
+
     Joins an array of strings with a delimiter.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("join")
         self._expected_parameter_count = 2
 

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

@@ -1,6 +1,6 @@
 """Keys function."""
 
-from typing import Any, List
+from typing import Any
 
 from .function import Function
 from .function_metadata import FunctionDef
@@ -17,11 +17,11 @@ from .function_metadata import FunctionDef
 })
 class Keys(Function):
     """Keys function.
-    
+
     Returns the keys of an object (associative array) as an array.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("keys")
         self._expected_parameter_count = 1
 

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

@@ -1,12 +1,13 @@
 """Base class for predicate functions in FlowQuery."""
 
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from ..ast_node import ASTNode
-from ..expressions.expression import Expression
-from ..expressions.reference import Reference
 from .value_holder import ValueHolder
 
+if TYPE_CHECKING:
+    pass
+
 
 class PredicateFunction(ASTNode):
     """Base class for predicate functions."""
@@ -21,7 +22,7 @@ class PredicateFunction(ASTNode):
         return self._name
 
     @property
-    def reference(self) -> Reference:
+    def reference(self) -> ASTNode:
         return self.first_child()
 
     @property
@@ -29,12 +30,12 @@ class PredicateFunction(ASTNode):
         return self.get_children()[1].first_child()
 
     @property
-    def _return(self) -> Expression:
+    def _return(self) -> ASTNode:
         return self.get_children()[2]
 
     @property
-    def where(self) -> Optional['Where']:
-        from ..operations.where import Where
+    def where(self) -> Optional[ASTNode]:
+        # Import at runtime to avoid circular dependency
         if len(self.get_children()) == 4:
             return self.get_children()[3]
         return None

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

@@ -1,13 +1,16 @@
 """PredicateSum function."""
 
-from typing import Any, List, Optional
+from typing import Any, Optional
 
-from .predicate_function import PredicateFunction
 from .function_metadata import FunctionDef
+from .predicate_function import PredicateFunction
 
 
 @FunctionDef({
-    "description": "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
+    "description": (
+        "Calculates the sum of values in an array with optional filtering. "
+        "Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)"
+    ),
     "category": "predicate",
     "parameters": [
         {"name": "variable", "description": "Variable name to bind each element", "type": "string"},
@@ -23,19 +26,21 @@ from .function_metadata import FunctionDef
 })
 class PredicateSum(PredicateFunction):
     """PredicateSum function.
-    
+
     Calculates the sum of values in an array with optional filtering.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("sum")
 
     def value(self) -> Any:
-        self.reference.referred = self._value_holder
+        ref = self.reference
+        if hasattr(ref, 'referred'):
+            ref.referred = self._value_holder
         array = self.array.value()
         if array is None or not isinstance(array, list):
             raise ValueError("Invalid array for sum function")
-        
+
         _sum: Optional[Any] = None
         for item in array:
             self._value_holder.holder = item

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

@@ -16,11 +16,11 @@ from .function_metadata import FunctionDef
 })
 class Rand(Function):
     """Rand function.
-    
+
     Generates a random number between 0 and 1.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("rand")
         self._expected_parameter_count = 0
 

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

@@ -1,6 +1,6 @@
 """Range function."""
 
-from typing import Any, List
+from typing import Any
 
 from .function import Function
 from .function_metadata import FunctionDef
@@ -13,16 +13,21 @@ from .function_metadata import FunctionDef
         {"name": "start", "description": "Starting number (inclusive)", "type": "number"},
         {"name": "end", "description": "Ending number (inclusive)", "type": "number"}
     ],
-    "output": {"description": "Array of integers from start to end", "type": "array", "items": {"type": "number"}, "example": [1, 2, 3, 4, 5]},
+    "output": {
+        "description": "Array of integers from start to end",
+        "type": "array",
+        "items": {"type": "number"},
+        "example": [1, 2, 3, 4, 5]
+    },
     "examples": ["WITH range(1, 5) AS nums RETURN nums"]
 })
 class Range(Function):
     """Range function.
-    
+
     Generates an array of sequential integers.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("range")
         self._expected_parameter_count = 2
 

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

@@ -20,11 +20,11 @@ from .function_metadata import FunctionDef
 })
 class Replace(Function):
     """Replace function.
-    
+
     Replaces occurrences of a pattern in a string.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("replace")
         self._expected_parameter_count = 3
 

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

@@ -17,11 +17,11 @@ from .function_metadata import FunctionDef
 })
 class Round(Function):
     """Round function.
-    
+
     Rounds a number to the nearest integer.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("round")
         self._expected_parameter_count = 1
 

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

@@ -17,11 +17,11 @@ from .function_metadata import FunctionDef
 })
 class Size(Function):
     """Size function.
-    
+
     Returns the length of an array or string.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("size")
         self._expected_parameter_count = 1
 

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

@@ -2,9 +2,9 @@
 
 from typing import Any, List
 
-from .function import Function
 from ..ast_node import ASTNode
 from ..expressions.string import String
+from .function import Function
 from .function_metadata import FunctionDef
 
 
@@ -15,16 +15,21 @@ from .function_metadata import FunctionDef
         {"name": "text", "description": "String to split", "type": "string"},
         {"name": "delimiter", "description": "Delimiter to split by", "type": "string"}
     ],
-    "output": {"description": "Array of string parts", "type": "array", "items": {"type": "string"}, "example": ["a", "b", "c"]},
+    "output": {
+        "description": "Array of string parts",
+        "type": "array",
+        "items": {"type": "string"},
+        "example": ["a", "b", "c"]
+    },
     "examples": ["WITH 'a,b,c' AS s RETURN split(s, ',')"]
 })
 class Split(Function):
     """Split function.
-    
+
     Splits a string into an array by a delimiter.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("split")
         self._expected_parameter_count = 2
 

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

@@ -3,9 +3,9 @@
 import json
 from typing import Any, List
 
-from .function import Function
 from ..ast_node import ASTNode
 from ..expressions.number import Number
+from .function import Function
 from .function_metadata import FunctionDef
 
 
@@ -20,11 +20,11 @@ from .function_metadata import FunctionDef
 })
 class Stringify(Function):
     """Stringify function.
-    
+
     Converts a value to its JSON string representation.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("stringify")
         self._expected_parameter_count = 2
 

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

@@ -3,14 +3,14 @@
 from typing import Any
 
 from .aggregate_function import AggregateFunction
-from .reducer_element import ReducerElement
 from .function_metadata import FunctionDef
+from .reducer_element import ReducerElement
 
 
 class SumReducerElement(ReducerElement):
     """Reducer element for Sum aggregate function."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._value: Any = None
 
     @property
@@ -36,11 +36,11 @@ class SumReducerElement(ReducerElement):
 })
 class Sum(AggregateFunction):
     """Sum aggregate function.
-    
+
     Calculates the sum of numeric values across grouped rows.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("sum")
         self._expected_parameter_count = 1
 

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

@@ -18,11 +18,11 @@ from .function_metadata import FunctionDef
 })
 class ToJson(Function):
     """ToJson function.
-    
+
     Parses a JSON string into an object.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("tojson")
         self._expected_parameter_count = 1
 

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

@@ -21,17 +21,17 @@ from .function_metadata import FunctionDef
 })
 class Type(Function):
     """Type function.
-    
+
     Returns the type of a value as a string.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("type")
         self._expected_parameter_count = 1
 
     def value(self) -> Any:
         val = self.get_children()[0].value()
-        
+
         if val is None:
             return "null"
         if isinstance(val, list):

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

@@ -8,7 +8,7 @@ from ..ast_node import ASTNode
 class ValueHolder(ASTNode):
     """Holds a value that can be set and retrieved."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self._holder: Any = None
 

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

@@ -1,10 +1,10 @@
 """Logic module for FlowQuery parsing."""
 
 from .case import Case
-from .when import When
-from .then import Then
 from .else_ import Else
 from .end import End
+from .then import Then
+from .when import When
 
 __all__ = [
     "Case",

package/flowquery-py/src/parsing/logic/case.py

@@ -4,7 +4,6 @@ from typing import Any
 
 from ..ast_node import ASTNode
 from .when import When
-from .then import Then
 
 
 class Case(ASTNode):

package/flowquery-py/src/parsing/logic/when.py

@@ -1,10 +1,12 @@
 """Represents a WHEN clause in a CASE expression."""
 
+from typing import Any
+
 from ..ast_node import ASTNode
 
 
 class When(ASTNode):
     """Represents a WHEN clause in a CASE expression."""
 
-    def value(self) -> bool:
+    def value(self) -> Any:
         return self.get_children()[0].value()

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

@@ -1,20 +1,20 @@
 """Operations module for FlowQuery parsing."""
 
-from .operation import Operation
-from .projection import Projection
-from .return_op import Return
-from .with_op import With
-from .unwind import Unwind
-from .load import Load
-from .where import Where
-from .limit import Limit
 from .aggregated_return import AggregatedReturn
 from .aggregated_with import AggregatedWith
 from .call import Call
-from .group_by import GroupBy
-from .match import Match
 from .create_node import CreateNode
 from .create_relationship import CreateRelationship
+from .group_by import GroupBy
+from .limit import Limit
+from .load import Load
+from .match import Match
+from .operation import Operation
+from .projection import Projection
+from .return_op import Return
+from .unwind import Unwind
+from .where import Where
+from .with_op import With
 
 __all__ = [
     "Operation",

package/flowquery-py/src/parsing/operations/aggregated_return.py

@@ -1,16 +1,14 @@
-"""Represents an aggregated RETURN operation."""
-
 from typing import Any, Dict, List
 
-from .return_op import Return
+from ..ast_node import ASTNode
 from .group_by import GroupBy
-from ..expressions.expression import Expression
+from .return_op import Return
 
 
 class AggregatedReturn(Return):
     """Represents an aggregated RETURN operation that groups and reduces values."""
 
-    def __init__(self, expressions):
+    def __init__(self, expressions: List[ASTNode]) -> None:
         super().__init__(expressions)
         self._group_by = GroupBy(self.children)
 

package/flowquery-py/src/parsing/operations/aggregated_with.py

@@ -1,14 +1,14 @@
-"""Represents an aggregated WITH operation."""
+from typing import List
 
-from .return_op import Return
+from ..ast_node import ASTNode
 from .group_by import GroupBy
-from ..expressions.expression import Expression
+from .return_op import Return
 
 
 class AggregatedWith(Return):
     """Represents an aggregated WITH operation that groups and reduces values."""
 
-    def __init__(self, expressions):
+    def __init__(self, expressions: List[ASTNode]) -> None:
         super().__init__(expressions)
         self._group_by = GroupBy(self.children)
 

package/flowquery-py/src/parsing/operations/call.py

@@ -2,19 +2,18 @@
 
 from typing import Any, Dict, List, Optional
 
-from ..expressions.expression import Expression
+from ..ast_node import ASTNode
 from ..expressions.expression_map import ExpressionMap
 from ..functions.async_function import AsyncFunction
 from .projection import Projection
 
-
 DEFAULT_VARIABLE_NAME = "value"
 
 
 class Call(Projection):
     """Represents a CALL operation for invoking async functions."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__([])
         self._function: Optional[AsyncFunction] = None
         self._map = ExpressionMap()
@@ -29,13 +28,13 @@ class Call(Projection):
         self._function = async_function
 
     @property
-    def yielded(self) -> List[Expression]:
+    def yielded(self) -> List[ASTNode]:
         return self.children
 
     @yielded.setter
-    def yielded(self, expressions: List[Expression]) -> None:
+    def yielded(self, expressions: List[ASTNode]) -> None:
         self.children = expressions
-        self._map.set_map(expressions)
+        self._map.set_map(expressions)  # ExpressionMap accepts list of expressions
 
     @property
     def has_yield(self) -> bool:
@@ -44,7 +43,7 @@ class Call(Projection):
     async def run(self) -> None:
         if self._function is None:
             raise ValueError("No function set for Call operation.")
-        
+
         args = self._function.get_arguments()
         async for item in self._function.generate(*args):
             if not self.is_last:

package/flowquery-py/src/parsing/operations/create_node.py

@@ -2,20 +2,22 @@
 
 from typing import Any, Dict, List
 
-from .operation import Operation
+from ...graph.database import Database
+from ...graph.node import Node
 from ..ast_node import ASTNode
+from .operation import Operation
 
 
 class CreateNode(Operation):
     """Represents a CREATE operation for creating virtual nodes."""
 
-    def __init__(self, node, statement: ASTNode):
+    def __init__(self, node: Node, statement: ASTNode) -> None:
         super().__init__()
         self._node = node
         self._statement = statement
 
     @property
-    def node(self):
+    def node(self) -> Node:
         return self._node
 
     @property
@@ -25,7 +27,6 @@ class CreateNode(Operation):
     async def run(self) -> None:
         if self._node is None:
             raise ValueError("Node is null")
-        from ...graph.database import Database
         db = Database.get_instance()
         db.add_node(self._node, self._statement)