flowquery 1.0.46 → 1.0.47

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

@@ -1,54 +0,0 @@
-"""Split function."""
-
-from typing import Any, List
-
-from ..ast_node import ASTNode
-from ..expressions.string import String
-from .function import Function
-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) -> None:
-        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 text is None:
-            return None
-        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/string_distance.py

@@ -1,92 +0,0 @@
-"""String distance function using Levenshtein distance."""
-
-from typing import Optional
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-def _levenshtein_distance(a: str, b: str) -> float:
-    """Compute the normalized Levenshtein distance between two strings.
-
-    The Levenshtein distance is the minimum number of single-character edits
-    (insertions, deletions, or substitutions) required to change one string
-    into the other. The result is normalized to [0, 1] by dividing by the
-    length of the longer string.
-
-    Args:
-        a: First string
-        b: Second string
-
-    Returns:
-        The normalized Levenshtein distance (0 = identical, 1 = completely different)
-    """
-    m = len(a)
-    n = len(b)
-
-    # Both empty strings are identical
-    if m == 0 and n == 0:
-        return 0.0
-
-    # Create a matrix of size (m+1) x (n+1)
-    dp = [[0] * (n + 1) for _ in range(m + 1)]
-
-    # Base cases: transforming empty string to/from a prefix
-    for i in range(m + 1):
-        dp[i][0] = i
-    for j in range(n + 1):
-        dp[0][j] = j
-
-    # Fill in the rest of the matrix
-    for i in range(1, m + 1):
-        for j in range(1, n + 1):
-            cost = 0 if a[i - 1] == b[j - 1] else 1
-            dp[i][j] = min(
-                dp[i - 1][j] + 1,       # deletion
-                dp[i][j - 1] + 1,       # insertion
-                dp[i - 1][j - 1] + cost  # substitution
-            )
-
-    # Normalize by the length of the longer string
-    return dp[m][n] / max(m, n)
-
-
-@FunctionDef({
-    "description": (
-        "Computes the normalized Levenshtein distance between two strings. "
-        "Returns a value in [0, 1] where 0 means identical and 1 means completely different."
-    ),
-    "category": "scalar",
-    "parameters": [
-        {"name": "string1", "description": "First string", "type": "string"},
-        {"name": "string2", "description": "Second string", "type": "string"}
-    ],
-    "output": {
-        "description": "Normalized Levenshtein distance (0 = identical, 1 = completely different)",
-        "type": "number",
-        "example": 0.43,
-    },
-    "examples": [
-        "RETURN string_distance('kitten', 'sitting')",
-        "WITH 'hello' AS a, 'hallo' AS b RETURN string_distance(a, b)"
-    ]
-})
-class StringDistance(Function):
-    """String distance function.
-
-    Computes the normalized Levenshtein distance between two strings.
-    Returns a value in [0, 1] where 0 means identical and 1 means completely different.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("string_distance")
-        self._expected_parameter_count = 2
-
-    def value(self) -> Optional[float]:
-        str1 = self.get_children()[0].value()
-        str2 = self.get_children()[1].value()
-        if str1 is None or str2 is None:
-            return None
-        if not isinstance(str1, str) or not isinstance(str2, str):
-            raise ValueError("Invalid arguments for string_distance function: both arguments must be strings")
-        return _levenshtein_distance(str1, str2)

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

@@ -1,49 +0,0 @@
-"""Stringify function."""
-
-import json
-from typing import Any, List
-
-from ..ast_node import ASTNode
-from ..expressions.number import Number
-from .function import Function
-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) -> None:
-        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 val is None:
-            return None
-        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/substring.py

@@ -1,76 +0,0 @@
-"""Substring function."""
-
-from typing import Any, List
-
-from ..ast_node import ASTNode
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Returns a substring of a string, starting at a 0-based index with an optional length",
-    "category": "scalar",
-    "parameters": [
-        {"name": "original", "description": "The original string", "type": "string"},
-        {"name": "start", "description": "The 0-based start index", "type": "integer"},
-        {
-            "name": "length",
-            "description": "The length of the substring (optional)",
-            "type": "integer",
-        }
-    ],
-    "output": {"description": "The substring", "type": "string", "example": "llo"},
-    "examples": [
-        "RETURN substring('hello', 1, 3)",
-        "RETURN substring('hello', 2)"
-    ]
-})
-class Substring(Function):
-    """Substring function.
-
-    Returns a substring of a string, starting at a 0-based index with an optional length.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("substring")
-
-    @property
-    def parameters(self) -> List[ASTNode]:
-        return self.get_children()
-
-    @parameters.setter
-    def parameters(self, nodes: List[ASTNode]) -> None:
-        if len(nodes) < 2 or len(nodes) > 3:
-            raise ValueError(
-                f"Function substring expected 2 or 3 parameters, but got {len(nodes)}"
-            )
-        for node in nodes:
-            self.add_child(node)
-
-    def value(self) -> Any:
-        children = self.get_children()
-        original = children[0].value()
-        start = children[1].value()
-
-        if original is None:
-            return None
-        if not isinstance(original, str):
-            raise ValueError(
-                "Invalid argument for substring function: expected a string as the first argument"
-            )
-        if not isinstance(start, (int, float)) or (isinstance(start, float) and not start.is_integer()):
-            raise ValueError(
-                "Invalid argument for substring function: expected an integer as the second argument"
-            )
-        start = int(start)
-
-        if len(children) == 3:
-            length = children[2].value()
-            if not isinstance(length, (int, float)) or (isinstance(length, float) and not length.is_integer()):
-                raise ValueError(
-                    "Invalid argument for substring function: expected an integer as the third argument"
-                )
-            length = int(length)
-            return original[start:start + length]
-
-        return original[start:]

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

@@ -1,51 +0,0 @@
-"""Sum aggregate function."""
-
-from typing import Any
-
-from .aggregate_function import AggregateFunction
-from .function_metadata import FunctionDef
-from .reducer_element import ReducerElement
-
-
-class SumReducerElement(ReducerElement):
-    """Reducer element for Sum 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 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) -> None:
-        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/tail.py

@@ -1,37 +0,0 @@
-"""Tail function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Returns all elements of a list except the first",
-    "category": "scalar",
-    "parameters": [
-        {"name": "list", "description": "The list to get all but the first element from", "type": "array"}
-    ],
-    "output": {"description": "All elements except the first", "type": "array", "example": [2, 3]},
-    "examples": [
-        "RETURN tail([1, 2, 3])",
-        "WITH ['a', 'b', 'c'] AS items RETURN tail(items)"
-    ]
-})
-class Tail(Function):
-    """Tail function.
-
-    Returns all elements of a list except the first.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("tail")
-        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):
-            raise ValueError("tail() expects a list")
-        return val[1:]

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

@@ -1,186 +0,0 @@
-"""Shared utility functions for temporal (date/time) operations.
-
-These helpers are used by the datetime_, date_, time_, localdatetime,
-localtime, and timestamp functions.
-"""
-
-from datetime import date, datetime, timezone
-from typing import Any, Dict
-
-
-def iso_day_of_week(d: date) -> int:
-    """Computes the ISO day of the week (1 = Monday, 7 = Sunday)."""
-    return d.isoweekday()
-
-
-def day_of_year(d: date) -> int:
-    """Computes the day of the year (1-based)."""
-    return d.timetuple().tm_yday
-
-
-def quarter(month: int) -> int:
-    """Computes the quarter (1-4) from a month (1-12)."""
-    return (month - 1) // 3 + 1
-
-
-def parse_temporal_arg(arg: Any, fn_name: str) -> datetime:
-    """Parses a temporal argument (string, number, or map) into a datetime object.
-
-    Args:
-        arg: The argument to parse (string, number, or dict with components)
-        fn_name: The calling function name for error messages
-
-    Returns:
-        A datetime object
-    """
-    if isinstance(arg, str):
-        try:
-            return datetime.fromisoformat(arg.replace("Z", "+00:00"))
-        except ValueError:
-            raise ValueError(f"{fn_name}(): Invalid temporal string: '{arg}'")
-
-    if isinstance(arg, (int, float)):
-        # Treat as epoch milliseconds
-        return datetime.fromtimestamp(arg / 1000, tz=timezone.utc)
-
-    if isinstance(arg, dict):
-        # Map-style construction: {year, month, day, hour, minute, second, millisecond}
-        now = datetime.now()
-        year = arg.get("year", now.year)
-        month = arg.get("month", 1)
-        day = arg.get("day", 1)
-        hour = arg.get("hour", 0)
-        minute = arg.get("minute", 0)
-        second = arg.get("second", 0)
-        millisecond = arg.get("millisecond", 0)
-        return datetime(year, month, day, hour, minute, second, millisecond * 1000)
-
-    raise ValueError(
-        f"{fn_name}(): Expected a string, number (epoch millis), or map argument, "
-        f"got {type(arg).__name__}"
-    )
-
-
-def build_datetime_object(d: datetime, utc: bool) -> Dict[str, Any]:
-    """Builds a datetime result object with full temporal properties.
-
-    Args:
-        d: The datetime object
-        utc: If True, use UTC values; if False, use local values
-
-    Returns:
-        A dict with year, month, day, hour, minute, second, millisecond,
-        epochMillis, epochSeconds, dayOfWeek, dayOfYear, quarter, formatted
-    """
-    if utc:
-        if d.tzinfo is None:
-            d = d.replace(tzinfo=timezone.utc)
-        d_utc = d.astimezone(timezone.utc)
-        year = d_utc.year
-        month = d_utc.month
-        day = d_utc.day
-        hour = d_utc.hour
-        minute = d_utc.minute
-        second = d_utc.second
-        millisecond = d_utc.microsecond // 1000
-        formatted = d_utc.strftime("%Y-%m-%dT%H:%M:%S.") + f"{millisecond:03d}Z"
-    else:
-        if d.tzinfo is not None:
-            d = d.astimezone(tz=None).replace(tzinfo=None)
-        year = d.year
-        month = d.month
-        day = d.day
-        hour = d.hour
-        minute = d.minute
-        second = d.second
-        millisecond = d.microsecond // 1000
-        formatted = d.strftime("%Y-%m-%dT%H:%M:%S.") + f"{millisecond:03d}"
-
-    date_part = date(year, month, day)
-    epoch_millis = int(d.timestamp() * 1000) if d.tzinfo else int(
-        datetime(year, month, day, hour, minute, second, millisecond * 1000).timestamp() * 1000
-    )
-
-    return {
-        "year": year,
-        "month": month,
-        "day": day,
-        "hour": hour,
-        "minute": minute,
-        "second": second,
-        "millisecond": millisecond,
-        "epochMillis": epoch_millis,
-        "epochSeconds": epoch_millis // 1000,
-        "dayOfWeek": iso_day_of_week(date_part),
-        "dayOfYear": day_of_year(date_part),
-        "quarter": quarter(month),
-        "formatted": formatted,
-    }
-
-
-def build_date_object(d: datetime) -> Dict[str, Any]:
-    """Builds a date result object (no time component).
-
-    Args:
-        d: The datetime object
-
-    Returns:
-        A dict with year, month, day, epochMillis, dayOfWeek, dayOfYear, quarter, formatted
-    """
-    year = d.year
-    month = d.month
-    day_val = d.day
-
-    date_only = datetime(year, month, day_val)
-    epoch_millis = int(date_only.timestamp() * 1000)
-
-    date_part = date(year, month, day_val)
-
-    return {
-        "year": year,
-        "month": month,
-        "day": day_val,
-        "epochMillis": epoch_millis,
-        "dayOfWeek": iso_day_of_week(date_part),
-        "dayOfYear": day_of_year(date_part),
-        "quarter": quarter(month),
-        "formatted": f"{year}-{month:02d}-{day_val:02d}",
-    }
-
-
-def build_time_object(d: datetime, utc: bool) -> Dict[str, Any]:
-    """Builds a time result object (no date component).
-
-    Args:
-        d: The datetime object
-        utc: If True, use UTC values; if False, use local values
-
-    Returns:
-        A dict with hour, minute, second, millisecond, formatted
-    """
-    if utc:
-        if d.tzinfo is None:
-            d = d.replace(tzinfo=timezone.utc)
-        d_utc = d.astimezone(timezone.utc)
-        hour = d_utc.hour
-        minute = d_utc.minute
-        second = d_utc.second
-        millisecond = d_utc.microsecond // 1000
-    else:
-        if d.tzinfo is not None:
-            d = d.astimezone(tz=None).replace(tzinfo=None)
-        hour = d.hour
-        minute = d.minute
-        second = d.second
-        millisecond = d.microsecond // 1000
-
-    time_part = f"{hour:02d}:{minute:02d}:{second:02d}.{millisecond:03d}"
-    formatted = f"{time_part}Z" if utc else time_part
-
-    return {
-        "hour": hour,
-        "minute": minute,
-        "second": second,
-        "millisecond": millisecond,
-        "formatted": formatted,
-    }

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

@@ -1,57 +0,0 @@
-"""Time function."""
-
-from datetime import datetime, timezone
-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 time value. With no arguments returns the current UTC time. "
-        "Accepts an ISO 8601 time string or a map of components (hour, minute, second, millisecond)."
-    ),
-    "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 time() AS now",
-        "RETURN time('12:30:00') AS t",
-        "WITH time() AS t RETURN t.hour, t.minute",
-    ],
-})
-class Time(Function):
-    """Time function.
-
-    Returns a time value (with timezone offset awareness).
-    When called with no arguments, returns the current UTC time.
-    When called with a string argument, parses it.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("time")
-        self._expected_parameter_count = None
-
-    def value(self) -> Any:
-        children = self.get_children()
-        if len(children) > 1:
-            raise ValueError("time() accepts at most one argument")
-
-        if len(children) == 1:
-            d = parse_temporal_arg(children[0].value(), "time")
-        else:
-            d = datetime.now(timezone.utc)
-
-        return build_time_object(d, utc=True)

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

@@ -1,37 +0,0 @@
-"""Timestamp function."""
-
-import time
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": (
-        "Returns the number of milliseconds since the Unix epoch (1970-01-01T00:00:00Z)."
-    ),
-    "category": "scalar",
-    "parameters": [],
-    "output": {
-        "description": "Milliseconds since Unix epoch",
-        "type": "number",
-        "example": 1718450000000,
-    },
-    "examples": [
-        "RETURN timestamp() AS ts",
-        "WITH timestamp() AS before, timestamp() AS after RETURN after - before",
-    ],
-})
-class Timestamp(Function):
-    """Timestamp function.
-
-    Returns the number of milliseconds since the Unix epoch (1970-01-01T00:00:00Z).
-    """
-
-    def __init__(self) -> None:
-        super().__init__("timestamp")
-        self._expected_parameter_count = 0
-
-    def value(self) -> Any:
-        return int(time.time() * 1000)

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

@@ -1,46 +0,0 @@
-"""ToFloat function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Converts a value to a floating point number",
-    "category": "scalar",
-    "parameters": [
-        {"name": "value", "description": "The value to convert to a float", "type": "any"}
-    ],
-    "output": {"description": "The floating point representation of the value", "type": "number", "example": 3.14},
-    "examples": [
-        'RETURN toFloat("3.14")',
-        "RETURN toFloat(42)",
-        "RETURN toFloat(true)"
-    ]
-})
-class ToFloat(Function):
-    """ToFloat function.
-
-    Converts a value to a floating point number.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("tofloat")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        val = self.get_children()[0].value()
-        if val is None:
-            return None
-        if isinstance(val, bool):
-            return 1.0 if val else 0.0
-        if isinstance(val, (int, float)):
-            return float(val)
-        if isinstance(val, str):
-            trimmed = val.strip()
-            try:
-                return float(trimmed)
-            except (ValueError, OverflowError):
-                raise ValueError(f'Cannot convert string "{val}" to float')
-        raise ValueError("toFloat() expects a number, string, or boolean")