flowquery 1.0.45 → 1.0.47

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

@@ -1,57 +0,0 @@
-"""Local time function."""
-
-from datetime import datetime
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-from .temporal_utils import build_time_object, parse_temporal_arg
-
-
-@FunctionDef({
-    "description": (
-        "Returns a local time value (no timezone). With no arguments returns the current local time. "
-        "Accepts an ISO 8601 time string or a map of components."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {
-            "name": "input",
-            "description": "Optional. An ISO 8601 time string (HH:MM:SS) or a map of components.",
-            "type": "string",
-            "required": False,
-        },
-    ],
-    "output": {
-        "description": "A time object with properties: hour, minute, second, millisecond, formatted",
-        "type": "object",
-    },
-    "examples": [
-        "RETURN localtime() AS now",
-        "RETURN localtime('14:30:00') AS t",
-        "WITH localtime() AS t RETURN t.hour, t.minute",
-    ],
-})
-class LocalTime(Function):
-    """Local time function.
-
-    Returns a local time value (no timezone offset).
-    When called with no arguments, returns the current local time.
-    When called with a string argument, parses it.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("localtime")
-        self._expected_parameter_count = None
-
-    def value(self) -> Any:
-        children = self.get_children()
-        if len(children) > 1:
-            raise ValueError("localtime() accepts at most one argument")
-
-        if len(children) == 1:
-            d = parse_temporal_arg(children[0].value(), "localtime")
-        else:
-            d = datetime.now()
-
-        return build_time_object(d, utc=False)

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

@@ -1,49 +0,0 @@
-"""Max aggregate function."""
-
-from typing import Any
-
-from .aggregate_function import AggregateFunction
-from .function_metadata import FunctionDef
-from .reducer_element import ReducerElement
-
-
-class MaxReducerElement(ReducerElement):
-    """Reducer element for Max aggregate function."""
-
-    def __init__(self) -> None:
-        self._value: Any = None
-
-    @property
-    def value(self) -> Any:
-        return self._value
-
-    @value.setter
-    def value(self, val: Any) -> None:
-        if self._value is None or val > self._value:
-            self._value = val
-
-
-@FunctionDef({
-    "description": "Returns the maximum value across grouped rows",
-    "category": "aggregate",
-    "parameters": [
-        {"name": "value", "description": "Value to compare", "type": "number"}
-    ],
-    "output": {"description": "Maximum value", "type": "number", "example": 10},
-    "examples": ["WITH [3, 1, 2] AS nums UNWIND nums AS n RETURN max(n)"]
-})
-class Max(AggregateFunction):
-    """Max aggregate function.
-
-    Returns the maximum value across grouped rows.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("max")
-        self._expected_parameter_count = 1
-
-    def reduce(self, element: MaxReducerElement) -> None:
-        element.value = self.first_child().value()
-
-    def element(self) -> MaxReducerElement:
-        return MaxReducerElement()

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

@@ -1,49 +0,0 @@
-"""Min aggregate function."""
-
-from typing import Any
-
-from .aggregate_function import AggregateFunction
-from .function_metadata import FunctionDef
-from .reducer_element import ReducerElement
-
-
-class MinReducerElement(ReducerElement):
-    """Reducer element for Min aggregate function."""
-
-    def __init__(self) -> None:
-        self._value: Any = None
-
-    @property
-    def value(self) -> Any:
-        return self._value
-
-    @value.setter
-    def value(self, val: Any) -> None:
-        if self._value is None or val < self._value:
-            self._value = val
-
-
-@FunctionDef({
-    "description": "Returns the minimum value across grouped rows",
-    "category": "aggregate",
-    "parameters": [
-        {"name": "value", "description": "Value to compare", "type": "number"}
-    ],
-    "output": {"description": "Minimum value", "type": "number", "example": 1},
-    "examples": ["WITH [3, 1, 2] AS nums UNWIND nums AS n RETURN min(n)"]
-})
-class Min(AggregateFunction):
-    """Min aggregate function.
-
-    Returns the minimum value across grouped rows.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("min")
-        self._expected_parameter_count = 1
-
-    def reduce(self, element: MinReducerElement) -> None:
-        element.value = self.first_child().value()
-
-    def element(self) -> MinReducerElement:
-        return MinReducerElement()

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

@@ -1,48 +0,0 @@
-"""Nodes function."""
-
-from typing import Any, List
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Returns all nodes in a path as an array",
-    "category": "scalar",
-    "parameters": [
-        {"name": "path", "description": "A path value returned from a graph pattern match", "type": "array"}
-    ],
-    "output": {
-        "description": "Array of node records", "type": "array",
-        "example": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
-    },
-    "examples": ["MATCH p=(:Person)-[:KNOWS]-(:Person) RETURN nodes(p)"]
-})
-class Nodes(Function):
-    """Nodes function.
-
-    Returns all nodes in a path as an array.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("nodes")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        path = self.get_children()[0].value()
-        if path is None:
-            return []
-        if not isinstance(path, list):
-            raise ValueError("nodes() expects a path (array)")
-        # A path is an array of alternating node and relationship objects:
-        # [node, rel, node, rel, node, ...]
-        # Nodes are plain dicts (have 'id' but not all of 'type'/'startNode'/'endNode'/'properties')
-        # Relationships are RelationshipMatchRecords (have 'type', 'startNode', 'endNode', 'properties')
-        result: List[Any] = []
-        for element in path:
-            if element is None or not isinstance(element, dict):
-                continue
-            # A RelationshipMatchRecord has type, startNode, endNode, properties
-            if not all(k in element for k in ("type", "startNode", "endNode", "properties")):
-                result.append(element)
-        return result

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

@@ -1,47 +0,0 @@
-"""Base class for predicate functions in FlowQuery."""
-
-from typing import TYPE_CHECKING, Any, Optional
-
-from ..ast_node import ASTNode
-from .value_holder import ValueHolder
-
-if TYPE_CHECKING:
-    pass
-
-
-class PredicateFunction(ASTNode):
-    """Base class for predicate functions."""
-
-    def __init__(self, name: Optional[str] = None):
-        super().__init__()
-        self._name = name or self.__class__.__name__
-        self._value_holder = ValueHolder()
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def reference(self) -> ASTNode:
-        return self.first_child()
-
-    @property
-    def array(self) -> ASTNode:
-        return self.get_children()[1].first_child()
-
-    @property
-    def _return(self) -> ASTNode:
-        return self.get_children()[2]
-
-    @property
-    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
-
-    def value(self) -> Any:
-        raise NotImplementedError("Method not implemented.")
-
-    def __str__(self) -> str:
-        return f"PredicateFunction ({self._name})"

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

@@ -1,49 +0,0 @@
-"""PredicateSum function."""
-
-from typing import Any
-
-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)"
-    ),
-    "category": "predicate",
-    "parameters": [
-        {"name": "variable", "description": "Variable name to bind each element", "type": "string"},
-        {"name": "array", "description": "Array to iterate over", "type": "array"},
-        {"name": "expression", "description": "Expression to sum for each element", "type": "any"},
-        {"name": "where", "description": "Optional filter condition", "type": "boolean", "required": False}
-    ],
-    "output": {"description": "Sum of the evaluated expressions", "type": "number", "example": 6},
-    "examples": [
-        "WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)",
-        "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)"
-    ]
-})
-class PredicateSum(PredicateFunction):
-    """PredicateSum function.
-
-    Calculates the sum of values in an array with optional filtering.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("sum")
-
-    def value(self) -> Any:
-        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: int = 0
-        for item in array:
-            self._value_holder.holder = item
-            if self.where is None or self.where.value():
-                _sum += self._return.value()
-        return _sum

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

@@ -1,50 +0,0 @@
-"""Properties function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": (
-        "Returns a map containing all the properties of a node, relationship, or map. "
-        "For nodes and relationships, internal identifiers are excluded."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {"name": "entity", "description": "A node, relationship, or map to extract properties from", "type": "object"}
-    ],
-    "output": {"description": "Map of properties", "type": "object", "example": {"name": "Alice", "age": 30}},
-    "examples": [
-        "MATCH (n:Person) RETURN properties(n)",
-        "WITH { name: 'Alice', age: 30 } AS obj RETURN properties(obj)"
-    ]
-})
-class Properties(Function):
-    """Properties function.
-
-    Returns a map containing all the properties of a node, relationship, or map.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("properties")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        obj = self.get_children()[0].value()
-        if obj is None:
-            return None
-        if not isinstance(obj, dict):
-            raise ValueError("properties() expects a node, relationship, or map")
-
-        # If it's a RelationshipMatchRecord (has type, startNode, endNode, properties)
-        if all(k in obj for k in ("type", "startNode", "endNode", "properties")):
-            return obj["properties"]
-
-        # If it's a node record (has id field), exclude id
-        if "id" in obj:
-            return {k: v for k, v in obj.items() if k != "id"}
-
-        # Otherwise, treat as a plain map and return a copy
-        return dict(obj)

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

@@ -1,28 +0,0 @@
-"""Rand function."""
-
-import random
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Generates a random number between 0 and 1",
-    "category": "scalar",
-    "parameters": [],
-    "output": {"description": "Random number between 0 and 1", "type": "number", "example": 0.7234},
-    "examples": ["WITH rand() AS r RETURN r"]
-})
-class Rand(Function):
-    """Rand function.
-
-    Generates a random number between 0 and 1.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("rand")
-        self._expected_parameter_count = 0
-
-    def value(self) -> Any:
-        return random.random()

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

@@ -1,41 +0,0 @@
-"""Range function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Generates an array of sequential integers",
-    "category": "scalar",
-    "parameters": [
-        {"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]
-    },
-    "examples": ["WITH range(1, 5) AS nums RETURN nums"]
-})
-class Range(Function):
-    """Range function.
-
-    Generates an array of sequential integers.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("range")
-        self._expected_parameter_count = 2
-
-    def value(self) -> Any:
-        start = self.get_children()[0].value()
-        end = self.get_children()[1].value()
-        if start is None or end is None:
-            return None
-        if not isinstance(start, (int, float)) or not isinstance(end, (int, float)):
-            raise ValueError("Invalid arguments for range function")
-        return list(range(int(start), int(end) + 1))

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

@@ -1,15 +0,0 @@
-"""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/relationships.py

@@ -1,46 +0,0 @@
-"""Relationships function."""
-
-from typing import Any, List
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Returns all relationships in a path as an array",
-    "category": "scalar",
-    "parameters": [
-        {"name": "path", "description": "A path value returned from a graph pattern match", "type": "array"}
-    ],
-    "output": {
-        "description": "Array of relationship records", "type": "array",
-        "example": [{"type": "KNOWS", "properties": {"since": "2020"}}]
-    },
-    "examples": ["MATCH p=(:Person)-[:KNOWS]-(:Person) RETURN relationships(p)"]
-})
-class Relationships(Function):
-    """Relationships function.
-
-    Returns all relationships in a path as an array.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("relationships")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        path = self.get_children()[0].value()
-        if path is None:
-            return []
-        if not isinstance(path, list):
-            raise ValueError("relationships() expects a path (array)")
-        # A path is an array of alternating node and relationship objects:
-        # [node, rel, node, rel, node, ...]
-        # Relationships are RelationshipMatchRecords (have 'type', 'startNode', 'endNode', 'properties')
-        result: List[Any] = []
-        for element in path:
-            if element is None or not isinstance(element, dict):
-                continue
-            if all(k in element for k in ("type", "startNode", "endNode", "properties")):
-                result.append(element)
-        return result

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

@@ -1,39 +0,0 @@
-"""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) -> None:
-        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 text is None:
-            return None
-        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

@@ -1,34 +0,0 @@
-"""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) -> None:
-        super().__init__("round")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        val = self.get_children()[0].value()
-        if val is None:
-            return None
-        if not isinstance(val, (int, float)):
-            raise ValueError("Invalid argument for round function")
-        return round(val)

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

@@ -1,40 +0,0 @@
-"""Schema introspection function."""
-
-from typing import Any, AsyncGenerator
-
-from .async_function import AsyncFunction
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": (
-        "Returns the graph schema listing all nodes and relationships "
-        "with their properties and a sample of their data."
-    ),
-    "category": "async",
-    "parameters": [],
-    "output": {
-        "description": "Schema entry with label/type, properties, and optional sample data",
-        "type": "object",
-    },
-    "examples": [
-        "CALL schema() YIELD label, type, from_label, to_label, properties, sample "
-        "RETURN label, type, from_label, to_label, properties, sample",
-    ],
-})
-class Schema(AsyncFunction):
-    """Returns the graph schema of the database.
-
-    Lists all nodes and relationships with their labels/types, properties,
-    and a sample of their data (excluding id from nodes, left_id and right_id from relationships).
-
-    Nodes: {label, properties, sample}
-    Relationships: {type, from_label, to_label, properties, sample}
-    """
-
-    async def generate(self) -> AsyncGenerator[Any, None]:
-        # Import at runtime to avoid circular dependency
-        from ...graph.database import Database
-        entries = await Database.get_instance().schema()
-        for entry in entries:
-            yield entry

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

@@ -1,34 +0,0 @@
-"""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) -> None:
-        super().__init__("size")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        val = self.get_children()[0].value()
-        if val is None:
-            return None
-        if not isinstance(val, (list, str)):
-            raise ValueError("Invalid argument for size function")
-        return len(val)