flowquery 1.0.16 → 1.0.17

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

@@ -0,0 +1,15 @@
+"""Reducer element for aggregate functions."""
+
+from typing import Any
+
+
+class ReducerElement:
+    """Base class for reducer elements used in aggregate functions."""
+
+    @property
+    def value(self) -> Any:
+        raise NotImplementedError("Method not implemented.")
+
+    @value.setter
+    def value(self, val: Any) -> None:
+        raise NotImplementedError("Method not implemented.")

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

@@ -0,0 +1,37 @@
+"""Replace function."""
+
+import re
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Replaces occurrences of a pattern in a string",
+    "category": "scalar",
+    "parameters": [
+        {"name": "text", "description": "Source string", "type": "string"},
+        {"name": "pattern", "description": "Pattern to find", "type": "string"},
+        {"name": "replacement", "description": "Replacement string", "type": "string"}
+    ],
+    "output": {"description": "String with replacements", "type": "string", "example": "hello world"},
+    "examples": ["WITH 'hello there' AS s RETURN replace(s, 'there', 'world')"]
+})
+class Replace(Function):
+    """Replace function.
+    
+    Replaces occurrences of a pattern in a string.
+    """
+
+    def __init__(self):
+        super().__init__("replace")
+        self._expected_parameter_count = 3
+
+    def value(self) -> Any:
+        text = self.get_children()[0].value()
+        pattern = self.get_children()[1].value()
+        replacement = self.get_children()[2].value()
+        if not isinstance(text, str) or not isinstance(pattern, str) or not isinstance(replacement, str):
+            raise ValueError("Invalid arguments for replace function")
+        return re.sub(re.escape(pattern), replacement, text)

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

@@ -0,0 +1,32 @@
+"""Round function."""
+
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Rounds a number to the nearest integer",
+    "category": "scalar",
+    "parameters": [
+        {"name": "value", "description": "Number to round", "type": "number"}
+    ],
+    "output": {"description": "Rounded integer", "type": "number", "example": 4},
+    "examples": ["WITH 3.7 AS n RETURN round(n)"]
+})
+class Round(Function):
+    """Round function.
+    
+    Rounds a number to the nearest integer.
+    """
+
+    def __init__(self):
+        super().__init__("round")
+        self._expected_parameter_count = 1
+
+    def value(self) -> Any:
+        val = self.get_children()[0].value()
+        if not isinstance(val, (int, float)):
+            raise ValueError("Invalid argument for round function")
+        return round(val)

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

@@ -0,0 +1,32 @@
+"""Size function."""
+
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Returns the length of an array or string",
+    "category": "scalar",
+    "parameters": [
+        {"name": "value", "description": "Array or string to measure", "type": "array"}
+    ],
+    "output": {"description": "Length of the input", "type": "number", "example": 3},
+    "examples": ["WITH [1, 2, 3] AS arr RETURN size(arr)"]
+})
+class Size(Function):
+    """Size function.
+    
+    Returns the length of an array or string.
+    """
+
+    def __init__(self):
+        super().__init__("size")
+        self._expected_parameter_count = 1
+
+    def value(self) -> Any:
+        val = self.get_children()[0].value()
+        if not isinstance(val, (list, str)):
+            raise ValueError("Invalid argument for size function")
+        return len(val)

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

@@ -0,0 +1,47 @@
+"""Split function."""
+
+from typing import Any, List
+
+from .function import Function
+from ..ast_node import ASTNode
+from ..expressions.string import String
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Splits a string into an array by a delimiter",
+    "category": "scalar",
+    "parameters": [
+        {"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"]},
+    "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):
+        super().__init__("split")
+        self._expected_parameter_count = 2
+
+    @property
+    def parameters(self) -> List[ASTNode]:
+        return self.get_children()
+
+    @parameters.setter
+    def parameters(self, nodes: List[ASTNode]) -> None:
+        if len(nodes) == 1:
+            nodes.append(String(""))
+        for node in nodes:
+            self.add_child(node)
+
+    def value(self) -> Any:
+        text = self.get_children()[0].value()
+        delimiter = self.get_children()[1].value()
+        if not isinstance(text, str) or not isinstance(delimiter, str):
+            raise ValueError("Invalid arguments for split function")
+        return text.split(delimiter)

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

@@ -0,0 +1,47 @@
+"""Stringify function."""
+
+import json
+from typing import Any, List
+
+from .function import Function
+from ..ast_node import ASTNode
+from ..expressions.number import Number
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Converts a value to its JSON string representation",
+    "category": "scalar",
+    "parameters": [
+        {"name": "value", "description": "Value to stringify", "type": "any"}
+    ],
+    "output": {"description": "JSON string", "type": "string", "example": '{"a":1}'},
+    "examples": ["WITH {a: 1} AS obj RETURN stringify(obj)"]
+})
+class Stringify(Function):
+    """Stringify function.
+    
+    Converts a value to its JSON string representation.
+    """
+
+    def __init__(self):
+        super().__init__("stringify")
+        self._expected_parameter_count = 2
+
+    @property
+    def parameters(self) -> List[ASTNode]:
+        return self.get_children()
+
+    @parameters.setter
+    def parameters(self, nodes: List[ASTNode]) -> None:
+        if len(nodes) == 1:
+            nodes.append(Number("3"))  # Default indent of 3
+        for node in nodes:
+            self.add_child(node)
+
+    def value(self) -> Any:
+        val = self.get_children()[0].value()
+        indent = int(self.get_children()[1].value())
+        if not isinstance(val, (dict, list)):
+            raise ValueError("Invalid argument for stringify function")
+        return json.dumps(val, indent=indent, default=str)

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

@@ -0,0 +1,51 @@
+"""Sum aggregate function."""
+
+from typing import Any
+
+from .aggregate_function import AggregateFunction
+from .reducer_element import ReducerElement
+from .function_metadata import FunctionDef
+
+
+class SumReducerElement(ReducerElement):
+    """Reducer element for Sum aggregate function."""
+
+    def __init__(self):
+        self._value: Any = None
+
+    @property
+    def value(self) -> Any:
+        return self._value
+
+    @value.setter
+    def value(self, val: Any) -> None:
+        if self._value is not None:
+            self._value += val
+        else:
+            self._value = val
+
+
+@FunctionDef({
+    "description": "Calculates the sum of numeric values across grouped rows",
+    "category": "aggregate",
+    "parameters": [
+        {"name": "value", "description": "Numeric value to sum", "type": "number"}
+    ],
+    "output": {"description": "Sum of all values", "type": "number", "example": 150},
+    "examples": ["WITH [1, 2, 3] AS nums UNWIND nums AS n RETURN sum(n)"]
+})
+class Sum(AggregateFunction):
+    """Sum aggregate function.
+    
+    Calculates the sum of numeric values across grouped rows.
+    """
+
+    def __init__(self):
+        super().__init__("sum")
+        self._expected_parameter_count = 1
+
+    def reduce(self, element: SumReducerElement) -> None:
+        element.value = self.first_child().value()
+
+    def element(self) -> SumReducerElement:
+        return SumReducerElement()

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

@@ -0,0 +1,33 @@
+"""ToJson function."""
+
+import json
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Parses a JSON string into an object",
+    "category": "scalar",
+    "parameters": [
+        {"name": "text", "description": "JSON string to parse", "type": "string"}
+    ],
+    "output": {"description": "Parsed object or array", "type": "object", "example": {"a": 1}},
+    "examples": ["WITH '{\"a\": 1}' AS s RETURN tojson(s)"]
+})
+class ToJson(Function):
+    """ToJson function.
+    
+    Parses a JSON string into an object.
+    """
+
+    def __init__(self):
+        super().__init__("tojson")
+        self._expected_parameter_count = 1
+
+    def value(self) -> Any:
+        text = self.get_children()[0].value()
+        if not isinstance(text, str):
+            raise ValueError("Invalid arguments for tojson function")
+        return json.loads(text)

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

@@ -0,0 +1,47 @@
+"""Type function."""
+
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Returns the type of a value as a string",
+    "category": "scalar",
+    "parameters": [
+        {"name": "value", "description": "Value to check the type of", "type": "any"}
+    ],
+    "output": {"description": "Type of the input value", "type": "string", "example": "string"},
+    "examples": [
+        "WITH 'hello' AS val RETURN type(val)",
+        "WITH 42 AS val RETURN type(val)",
+        "WITH [1, 2, 3] AS val RETURN type(val)"
+    ]
+})
+class Type(Function):
+    """Type function.
+    
+    Returns the type of a value as a string.
+    """
+
+    def __init__(self):
+        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):
+            return "array"
+        if isinstance(val, dict):
+            return "object"
+        if isinstance(val, bool):
+            return "boolean"
+        if isinstance(val, (int, float)):
+            return "number"
+        if isinstance(val, str):
+            return "string"
+        return type(val).__name__

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

@@ -0,0 +1,24 @@
+"""Value holder node for FlowQuery AST."""
+
+from typing import Any
+
+from ..ast_node import ASTNode
+
+
+class ValueHolder(ASTNode):
+    """Holds a value that can be set and retrieved."""
+
+    def __init__(self):
+        super().__init__()
+        self._holder: Any = None
+
+    @property
+    def holder(self) -> Any:
+        return self._holder
+
+    @holder.setter
+    def holder(self, value: Any) -> None:
+        self._holder = value
+
+    def value(self) -> Any:
+        return self._holder

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

@@ -0,0 +1,15 @@
+"""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
+
+__all__ = [
+    "Case",
+    "When",
+    "Then",
+    "Else",
+    "End",
+]

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

@@ -0,0 +1,29 @@
+"""Represents a CASE expression in the AST."""
+
+from typing import Any
+
+from ..ast_node import ASTNode
+from .when import When
+from .then import Then
+
+
+class Case(ASTNode):
+    """Represents a CASE expression in the AST."""
+
+    def value(self) -> Any:
+        i = 0
+        children = self.get_children()
+        child = children[i]
+        while isinstance(child, When):
+            then = children[i + 1]
+            if child.value():
+                return then.value()
+            i += 2
+            if i < len(children):
+                child = children[i]
+            else:
+                break
+        # Return the else clause if exists
+        if i < len(children):
+            return children[i].value()
+        return None

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

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

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

@@ -0,0 +1,8 @@
+"""Represents an END marker in a CASE expression."""
+
+from ..ast_node import ASTNode
+
+
+class End(ASTNode):
+    """Represents an END marker in a CASE expression."""
+    pass

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

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

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

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

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

@@ -0,0 +1,35 @@
+"""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
+
+__all__ = [
+    "Operation",
+    "Projection",
+    "Return",
+    "With",
+    "Unwind",
+    "Load",
+    "Where",
+    "Limit",
+    "AggregatedReturn",
+    "AggregatedWith",
+    "Call",
+    "GroupBy",
+    "Match",
+    "CreateNode",
+    "CreateRelationship",
+]

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

@@ -0,0 +1,24 @@
+"""Represents an aggregated RETURN operation."""
+
+from typing import Any, Dict, List
+
+from .return_op import Return
+from .group_by import GroupBy
+from ..expressions.expression import Expression
+
+
+class AggregatedReturn(Return):
+    """Represents an aggregated RETURN operation that groups and reduces values."""
+
+    def __init__(self, expressions):
+        super().__init__(expressions)
+        self._group_by = GroupBy(self.children)
+
+    async def run(self) -> None:
+        await self._group_by.run()
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        if self._where is not None:
+            self._group_by.where = self._where
+        return list(self._group_by.generate_results())

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

@@ -0,0 +1,22 @@
+"""Represents an aggregated WITH operation."""
+
+from .return_op import Return
+from .group_by import GroupBy
+from ..expressions.expression import Expression
+
+
+class AggregatedWith(Return):
+    """Represents an aggregated WITH operation that groups and reduces values."""
+
+    def __init__(self, expressions):
+        super().__init__(expressions)
+        self._group_by = GroupBy(self.children)
+
+    async def run(self) -> None:
+        await self._group_by.run()
+
+    async def finish(self) -> None:
+        for _ in self._group_by.generate_results():
+            if self.next:
+                await self.next.run()
+        await super().finish()

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

@@ -0,0 +1,74 @@
+"""Represents a CALL operation for invoking async functions."""
+
+from typing import Any, Dict, List, Optional
+
+from ..expressions.expression import Expression
+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):
+        super().__init__([])
+        self._function: Optional[AsyncFunction] = None
+        self._map = ExpressionMap()
+        self._results: List[Dict[str, Any]] = []
+
+    @property
+    def function(self) -> Optional[AsyncFunction]:
+        return self._function
+
+    @function.setter
+    def function(self, async_function: AsyncFunction) -> None:
+        self._function = async_function
+
+    @property
+    def yielded(self) -> List[Expression]:
+        return self.children
+
+    @yielded.setter
+    def yielded(self, expressions: List[Expression]) -> None:
+        self.children = expressions
+        self._map.set_map(expressions)
+
+    @property
+    def has_yield(self) -> bool:
+        return len(self.children) > 0
+
+    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:
+                if isinstance(item, dict):
+                    for key, value in item.items():
+                        expression = self._map.get(key)
+                        if expression:
+                            expression.overridden = value
+                else:
+                    expression = self._map.get(DEFAULT_VARIABLE_NAME)
+                    if expression:
+                        expression.overridden = item
+                if self.next:
+                    await self.next.run()
+            else:
+                record: Dict[str, Any] = {}
+                if isinstance(item, dict):
+                    for key, value in item.items():
+                        if self._map.has(key) or not self.has_yield:
+                            record[key] = value
+                else:
+                    record[DEFAULT_VARIABLE_NAME] = item
+                self._results.append(record)
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return self._results

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

@@ -0,0 +1,34 @@
+"""Represents a CREATE operation for creating virtual nodes."""
+
+from typing import Any, Dict, List
+
+from .operation import Operation
+from ..ast_node import ASTNode
+
+
+class CreateNode(Operation):
+    """Represents a CREATE operation for creating virtual nodes."""
+
+    def __init__(self, node, statement: ASTNode):
+        super().__init__()
+        self._node = node
+        self._statement = statement
+
+    @property
+    def node(self):
+        return self._node
+
+    @property
+    def statement(self) -> ASTNode:
+        return self._statement
+
+    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)
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return []