flowquery 1.0.46 → 1.0.47

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

@@ -1,55 +0,0 @@
-"""Avg aggregate function."""
-
-from typing import Optional
-
-from .aggregate_function import AggregateFunction
-from .function_metadata import FunctionDef
-from .reducer_element import ReducerElement
-
-
-class AvgReducerElement(ReducerElement):
-    """Reducer element for Avg aggregate function."""
-
-    def __init__(self) -> None:
-        self._count: int = 0
-        self._sum: Optional[float] = None
-
-    @property
-    def value(self) -> Optional[float]:
-        if self._sum is None:
-            return None
-        return self._sum / self._count
-
-    @value.setter
-    def value(self, val: float) -> None:
-        self._count += 1
-        if self._sum is not None:
-            self._sum += val
-        else:
-            self._sum = val
-
-
-@FunctionDef({
-    "description": "Calculates the average of numeric values across grouped rows",
-    "category": "aggregate",
-    "parameters": [
-        {"name": "value", "description": "Numeric value to average", "type": "number"}
-    ],
-    "output": {"description": "Average of all values", "type": "number", "example": 50},
-    "examples": ["WITH [10, 20, 30] AS nums UNWIND nums AS n RETURN avg(n)"]
-})
-class Avg(AggregateFunction):
-    """Avg aggregate function.
-
-    Calculates the average of numeric values across grouped rows.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("avg")
-        self._expected_parameter_count = 1
-
-    def reduce(self, element: AvgReducerElement) -> None:
-        element.value = self.first_child().value()
-
-    def element(self) -> AvgReducerElement:
-        return AvgReducerElement()

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

@@ -1,43 +0,0 @@
-"""Coalesce function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Returns the first non-null value from a list of expressions",
-    "category": "scalar",
-    "parameters": [
-        {"name": "expressions", "description": "Two or more expressions to evaluate", "type": "any"}
-    ],
-    "output": {"description": "The first non-null value, or null if all values are null", "type": "any"},
-    "examples": [
-        "RETURN coalesce(null, 'hello', 'world')",
-        "MATCH (n) RETURN coalesce(n.nickname, n.name) AS displayName"
-    ]
-})
-class Coalesce(Function):
-    """Coalesce function.
-
-    Returns the first non-null value from a list of expressions.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("coalesce")
-        self._expected_parameter_count = None  # variable number of parameters
-
-    def value(self) -> Any:
-        children = self.get_children()
-        if len(children) == 0:
-            raise ValueError("coalesce() requires at least one argument")
-        for child in children:
-            try:
-                val = child.value()
-            except (KeyError, AttributeError):
-                # Treat missing properties/keys as null
-                val = None
-            if val is not None:
-                return val
-        return None

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

@@ -1,75 +0,0 @@
-"""Collect aggregate function."""
-
-import json
-from typing import Any, Dict, List, Union
-
-from .aggregate_function import AggregateFunction
-from .function_metadata import FunctionDef
-from .reducer_element import ReducerElement
-
-
-class CollectReducerElement(ReducerElement):
-    """Reducer element for Collect aggregate function."""
-
-    def __init__(self) -> None:
-        self._value: List[Any] = []
-
-    @property
-    def value(self) -> Any:
-        return self._value
-
-    @value.setter
-    def value(self, val: Any) -> None:
-        self._value.append(val)
-
-
-class DistinctCollectReducerElement(ReducerElement):
-    """Reducer element for Collect aggregate function with DISTINCT."""
-
-    def __init__(self) -> None:
-        self._value: Dict[str, Any] = {}
-
-    @property
-    def value(self) -> Any:
-        return list(self._value.values())
-
-    @value.setter
-    def value(self, val: Any) -> None:
-        key: str = json.dumps(val, sort_keys=True, default=str)
-        if key not in self._value:
-            self._value[key] = val
-
-
-@FunctionDef({
-    "description": "Collects values into an array across grouped rows",
-    "category": "aggregate",
-    "parameters": [
-        {"name": "value", "description": "Value to collect", "type": "any"}
-    ],
-    "output": {"description": "Array of collected values", "type": "array", "example": [1, 2, 3]},
-    "examples": ["WITH [1, 2, 3] AS nums UNWIND nums AS n RETURN collect(n)"]
-})
-class Collect(AggregateFunction):
-    """Collect aggregate function.
-
-    Collects values into an array across grouped rows.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("collect")
-        self._expected_parameter_count = 1
-        self._distinct: bool = False
-
-    def reduce(self, element: CollectReducerElement) -> None:
-        element.value = self.first_child().value()
-
-    def element(self) -> Union[CollectReducerElement, DistinctCollectReducerElement]:
-        return DistinctCollectReducerElement() if self._distinct else CollectReducerElement()
-
-    @property
-    def distinct(self) -> bool:
-        return self._distinct
-
-    @distinct.setter
-    def distinct(self, val: bool) -> None:
-        self._distinct = val

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

@@ -1,79 +0,0 @@
-"""Count aggregate function."""
-
-import json
-from typing import Any, Union
-
-from .aggregate_function import AggregateFunction
-from .function_metadata import FunctionDef
-from .reducer_element import ReducerElement
-
-
-class CountReducerElement(ReducerElement):
-    """Reducer element for Count aggregate function."""
-
-    def __init__(self) -> None:
-        self._value: int = 0
-
-    @property
-    def value(self) -> Any:
-        return self._value
-
-    @value.setter
-    def value(self, val: Any) -> None:
-        self._value += 1
-
-
-class DistinctCountReducerElement(ReducerElement):
-    """Reducer element for Count aggregate function with DISTINCT."""
-
-    def __init__(self) -> None:
-        self._seen: set[Any] = set()
-
-    @property
-    def value(self) -> Any:
-        return len(self._seen)
-
-    @value.setter
-    def value(self, val: Any) -> None:
-        key: str = json.dumps(val, sort_keys=True, default=str)
-        self._seen.add(key)
-
-
-@FunctionDef({
-    "description": "Counts the number of values across grouped rows",
-    "category": "aggregate",
-    "parameters": [
-        {"name": "value", "description": "Value to count", "type": "any"}
-    ],
-    "output": {"description": "Number of values", "type": "number", "example": 3},
-    "examples": [
-        "WITH [1, 2, 3] AS nums UNWIND nums AS n RETURN count(n)",
-        "WITH [1, 2, 2, 3] AS nums UNWIND nums AS n RETURN count(distinct n)"
-    ]
-})
-class Count(AggregateFunction):
-    """Count aggregate function.
-
-    Counts the number of values across grouped rows.
-    Supports DISTINCT to count only unique values.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("count")
-        self._expected_parameter_count = 1
-        self._supports_distinct = True
-        self._distinct: bool = False
-
-    def reduce(self, element: Union[CountReducerElement, DistinctCountReducerElement]) -> None:
-        element.value = self.first_child().value()
-
-    def element(self) -> Union[CountReducerElement, DistinctCountReducerElement]:
-        return DistinctCountReducerElement() if self._distinct else CountReducerElement()
-
-    @property
-    def distinct(self) -> bool:
-        return self._distinct
-
-    @distinct.setter
-    def distinct(self, val: bool) -> None:
-        self._distinct = val

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

@@ -1,61 +0,0 @@
-"""Date function."""
-
-from datetime import datetime
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-from .temporal_utils import build_date_object, parse_temporal_arg
-
-
-@FunctionDef({
-    "description": (
-        "Returns a date value. With no arguments returns the current date. "
-        "Accepts an ISO 8601 date string or a map of components (year, month, day)."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {
-            "name": "input",
-            "description": "Optional. An ISO 8601 date string (YYYY-MM-DD) or a map of components.",
-            "type": "string",
-            "required": False,
-        },
-    ],
-    "output": {
-        "description": (
-            "A date object with properties: year, month, day, "
-            "epochMillis, dayOfWeek, dayOfYear, quarter, formatted"
-        ),
-        "type": "object",
-    },
-    "examples": [
-        "RETURN date() AS today",
-        "RETURN date('2025-06-15') AS d",
-        "RETURN date({year: 2025, month: 6, day: 15}) AS d",
-        "WITH date() AS d RETURN d.year, d.month, d.dayOfWeek",
-    ],
-})
-class DateFunction(Function):
-    """Date function.
-
-    Returns a date value (no time component).
-    When called with no arguments, returns the current date.
-    When called with a string argument, parses it as an ISO 8601 date.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("date")
-        self._expected_parameter_count = None
-
-    def value(self) -> Any:
-        children = self.get_children()
-        if len(children) > 1:
-            raise ValueError("date() accepts at most one argument")
-
-        if len(children) == 1:
-            d = parse_temporal_arg(children[0].value(), "date")
-        else:
-            d = datetime.now()
-
-        return build_date_object(d)

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

@@ -1,62 +0,0 @@
-"""Datetime function."""
-
-from datetime import datetime, timezone
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-from .temporal_utils import build_datetime_object, parse_temporal_arg
-
-
-@FunctionDef({
-    "description": (
-        "Returns a datetime value. With no arguments returns the current UTC datetime. "
-        "Accepts an ISO 8601 string or a map of components (year, month, day, hour, minute, second, millisecond)."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {
-            "name": "input",
-            "description": "Optional. An ISO 8601 datetime string or a map of components.",
-            "type": "string",
-            "required": False,
-        },
-    ],
-    "output": {
-        "description": (
-            "A datetime object with properties: year, month, day, hour, minute, second, millisecond, "
-            "epochMillis, epochSeconds, dayOfWeek, dayOfYear, quarter, formatted"
-        ),
-        "type": "object",
-    },
-    "examples": [
-        "RETURN datetime() AS now",
-        "RETURN datetime('2025-06-15T12:30:00Z') AS dt",
-        "RETURN datetime({year: 2025, month: 6, day: 15, hour: 12}) AS dt",
-        "WITH datetime() AS dt RETURN dt.year, dt.month, dt.day",
-    ],
-})
-class Datetime(Function):
-    """Datetime function.
-
-    Returns a datetime value (date + time + timezone offset).
-    When called with no arguments, returns the current UTC datetime.
-    When called with a string argument, parses it as an ISO 8601 datetime.
-    When called with a map argument, constructs a datetime from components.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("datetime")
-        self._expected_parameter_count = None
-
-    def value(self) -> Any:
-        children = self.get_children()
-        if len(children) > 1:
-            raise ValueError("datetime() accepts at most one argument")
-
-        if len(children) == 1:
-            d = parse_temporal_arg(children[0].value(), "datetime")
-        else:
-            d = datetime.now(timezone.utc)
-
-        return build_datetime_object(d, utc=True)

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

@@ -1,159 +0,0 @@
-"""Duration function."""
-
-import re
-from typing import Any, Dict
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-ISO_DURATION_REGEX = re.compile(
-    r"^P(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?"
-    r"(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?"
-    r"(?:(\d+(?:\.\d+)?)S)?)?$"
-)
-
-
-def _parse_duration_string(s: str) -> Dict[str, float]:
-    """Parse an ISO 8601 duration string into components."""
-    match = ISO_DURATION_REGEX.match(s)
-    if not match:
-        raise ValueError(f"duration(): Invalid ISO 8601 duration string: '{s}'")
-    return {
-        "years": float(match.group(1)) if match.group(1) else 0,
-        "months": float(match.group(2)) if match.group(2) else 0,
-        "weeks": float(match.group(3)) if match.group(3) else 0,
-        "days": float(match.group(4)) if match.group(4) else 0,
-        "hours": float(match.group(5)) if match.group(5) else 0,
-        "minutes": float(match.group(6)) if match.group(6) else 0,
-        "seconds": float(match.group(7)) if match.group(7) else 0,
-    }
-
-
-def _build_duration_object(components: Dict[str, Any]) -> Dict[str, Any]:
-    """Build a duration result object from components."""
-    years = components.get("years", 0) or 0
-    months = components.get("months", 0) or 0
-    weeks = components.get("weeks", 0) or 0
-    days = components.get("days", 0) or 0
-    hours = components.get("hours", 0) or 0
-    minutes = components.get("minutes", 0) or 0
-    raw_seconds = components.get("seconds", 0) or 0
-    seconds = int(raw_seconds)
-    fractional_seconds = raw_seconds - seconds
-
-    if "milliseconds" in components and components["milliseconds"]:
-        milliseconds = int(components["milliseconds"])
-    else:
-        milliseconds = round(fractional_seconds * 1000)
-
-    if "nanoseconds" in components and components["nanoseconds"]:
-        nanoseconds = int(components["nanoseconds"])
-    else:
-        nanoseconds = round(fractional_seconds * 1_000_000_000) % 1_000_000
-
-    # Total days including weeks
-    total_days = int(days + weeks * 7)
-
-    # Total seconds for the time portion
-    total_seconds = int(hours * 3600 + minutes * 60 + seconds)
-
-    # Total months
-    total_months = int(years * 12 + months)
-
-    # Build ISO 8601 formatted string
-    formatted = "P"
-    if years:
-        formatted += f"{int(years)}Y"
-    if months:
-        formatted += f"{int(months)}M"
-    if weeks:
-        formatted += f"{int(weeks)}W"
-    raw_days = int(total_days - weeks * 7)
-    if raw_days:
-        formatted += f"{raw_days}D"
-    has_time = hours or minutes or seconds or milliseconds
-    if has_time:
-        formatted += "T"
-        if hours:
-            formatted += f"{int(hours)}H"
-        if minutes:
-            formatted += f"{int(minutes)}M"
-        if seconds or milliseconds:
-            if milliseconds:
-                formatted += f"{seconds}.{milliseconds:03d}S"
-            else:
-                formatted += f"{seconds}S"
-    if formatted == "P":
-        formatted = "PT0S"
-
-    return {
-        "years": int(years),
-        "months": int(months),
-        "weeks": int(weeks),
-        "days": total_days,
-        "hours": int(hours),
-        "minutes": int(minutes),
-        "seconds": seconds,
-        "milliseconds": milliseconds,
-        "nanoseconds": nanoseconds,
-        "totalMonths": total_months,
-        "totalDays": total_days,
-        "totalSeconds": total_seconds,
-        "formatted": formatted,
-    }
-
-
-@FunctionDef({
-    "description": (
-        "Creates a duration value representing a span of time. "
-        "Accepts an ISO 8601 duration string (e.g., 'P1Y2M3DT4H5M6S') or a map of components "
-        "(years, months, weeks, days, hours, minutes, seconds, milliseconds, nanoseconds)."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {
-            "name": "input",
-            "description": (
-                "An ISO 8601 duration string or a map of components "
-                "(years, months, weeks, days, hours, minutes, seconds, milliseconds, nanoseconds)"
-            ),
-            "type": "any",
-        }
-    ],
-    "output": {
-        "description": (
-            "A duration object with properties: years, months, weeks, days, hours, minutes, seconds, "
-            "milliseconds, nanoseconds, totalMonths, totalDays, totalSeconds, formatted"
-        ),
-        "type": "object",
-    },
-    "examples": [
-        "RETURN duration('P1Y2M3D') AS d",
-        "RETURN duration('PT2H30M') AS d",
-        "RETURN duration({days: 14, hours: 16}) AS d",
-        "RETURN duration({months: 5, days: 1, hours: 12}) AS d",
-    ],
-})
-class Duration(Function):
-    """Duration function.
-
-    Creates a duration value representing a span of time.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("duration")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        arg = self.get_children()[0].value()
-        if arg is None:
-            return None
-
-        if isinstance(arg, str):
-            components = _parse_duration_string(arg)
-            return _build_duration_object(components)
-
-        if isinstance(arg, dict):
-            return _build_duration_object(arg)
-
-        raise ValueError("duration() expects a string or map argument")

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

@@ -1,50 +0,0 @@
-"""ElementId function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": (
-        "Returns the element id of a node or relationship as a string. "
-        "For nodes, returns the string representation of the id property. "
-        "For relationships, returns the type."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {"name": "entity", "description": "A node or relationship to get the element id from", "type": "object"}
-    ],
-    "output": {"description": "The element id of the entity as a string", "type": "string", "example": "\"1\""},
-    "examples": [
-        "MATCH (n:Person) RETURN elementId(n)",
-        "MATCH (a)-[r]->(b) RETURN elementId(r)"
-    ]
-})
-class ElementId(Function):
-    """ElementId function.
-
-    Returns the element id of a node or relationship as a string.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("elementid")
-        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("elementId() expects a node or relationship")
-
-        # If it's a RelationshipMatchRecord (has type, startNode, endNode, properties)
-        if all(k in obj for k in ("type", "startNode", "endNode", "properties")):
-            return str(obj["type"])
-
-        # If it's a node record (has id field)
-        if "id" in obj:
-            return str(obj["id"])
-
-        raise ValueError("elementId() expects a node or relationship")

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

@@ -1,68 +0,0 @@
-"""Base class for all functions in FlowQuery."""
-
-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]
-    """
-
-    def __init__(self, name: Optional[str] = None):
-        """Creates a new Function with the given name.
-
-        Args:
-            name: The function name
-        """
-        super().__init__()
-        self._name = name or self.__class__.__name__
-        self._expected_parameter_count: Optional[int] = None
-        self._supports_distinct: bool = False
-
-    @property
-    def parameters(self) -> List[ASTNode]:
-        """Gets the function parameters."""
-        return self.children
-
-    @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
-        """
-        if self._expected_parameter_count is not None and self._expected_parameter_count != len(nodes):
-            raise ValueError(
-                f"Function {self._name} expected {self._expected_parameter_count} parameters, "
-                f"but got {len(nodes)}"
-            )
-        self.children = nodes
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    def __str__(self) -> str:
-        return f"Function ({self._name})"
-
-    @property
-    def distinct(self) -> bool:
-        return self._supports_distinct
-
-    @distinct.setter
-    def distinct(self, value: bool) -> None:
-        if self._supports_distinct:
-            self._supports_distinct = value
-        else:
-            raise ValueError(f"Function {self._name} does not support distinct")