flowquery 1.0.46 → 1.0.48

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

@@ -1,46 +0,0 @@
-"""ToInteger function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Converts a value to an integer",
-    "category": "scalar",
-    "parameters": [
-        {"name": "value", "description": "The value to convert to an integer", "type": "any"}
-    ],
-    "output": {"description": "The integer representation of the value", "type": "number", "example": 42},
-    "examples": [
-        'RETURN toInteger("42")',
-        "RETURN toInteger(3.14)",
-        "RETURN toInteger(true)"
-    ]
-})
-class ToInteger(Function):
-    """ToInteger function.
-
-    Converts a value to an integer.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("tointeger")
-        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 if val else 0
-        if isinstance(val, (int, float)):
-            return int(val)
-        if isinstance(val, str):
-            trimmed = val.strip()
-            try:
-                return int(float(trimmed))
-            except (ValueError, OverflowError):
-                raise ValueError(f'Cannot convert string "{val}" to integer')
-        raise ValueError("toInteger() expects a number, string, or boolean")

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

@@ -1,35 +0,0 @@
-"""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) -> None:
-        super().__init__("tojson")
-        self._expected_parameter_count = 1
-
-    def value(self) -> Any:
-        text = self.get_children()[0].value()
-        if text is None:
-            return None
-        if not isinstance(text, str):
-            raise ValueError("Invalid arguments for tojson function")
-        return json.loads(text)

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

@@ -1,37 +0,0 @@
-"""ToLower function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Converts a string to lowercase",
-    "category": "scalar",
-    "parameters": [
-        {"name": "text", "description": "String to convert to lowercase", "type": "string"}
-    ],
-    "output": {"description": "Lowercase string", "type": "string", "example": "hello world"},
-    "examples": [
-        "WITH 'Hello World' AS s RETURN toLower(s)",
-        "WITH 'FOO' AS s RETURN toLower(s)"
-    ]
-})
-class ToLower(Function):
-    """ToLower function.
-
-    Converts a string to lowercase.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("tolower")
-        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, str):
-            raise ValueError("Invalid argument for toLower function: expected a string")
-        return val.lower()

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

@@ -1,41 +0,0 @@
-"""ToString function."""
-
-import json
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Converts a value to its string representation",
-    "category": "scalar",
-    "parameters": [
-        {"name": "value", "description": "Value to convert to a string", "type": "any"}
-    ],
-    "output": {"description": "String representation of the value", "type": "string", "example": "42"},
-    "examples": [
-        "WITH 42 AS n RETURN toString(n)",
-        "WITH true AS b RETURN toString(b)",
-        "WITH [1, 2, 3] AS arr RETURN toString(arr)"
-    ]
-})
-class ToString(Function):
-    """ToString function.
-
-    Converts a value to its string representation.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("tostring")
-        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 str(val).lower()
-        if isinstance(val, (dict, list)):
-            return json.dumps(val)
-        return str(val)

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

@@ -1,37 +0,0 @@
-"""Trim function."""
-
-from typing import Any
-
-from .function import Function
-from .function_metadata import FunctionDef
-
-
-@FunctionDef({
-    "description": "Removes leading and trailing whitespace from a string",
-    "category": "scalar",
-    "parameters": [
-        {"name": "text", "description": "String to trim", "type": "string"}
-    ],
-    "output": {"description": "Trimmed string", "type": "string", "example": "hello"},
-    "examples": [
-        "WITH '  hello  ' AS s RETURN trim(s)",
-        "WITH '\\tfoo\\n' AS s RETURN trim(s)"
-    ]
-})
-class Trim(Function):
-    """Trim function.
-
-    Removes leading and trailing whitespace from a string.
-    """
-
-    def __init__(self) -> None:
-        super().__init__("trim")
-        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, str):
-            raise ValueError("Invalid argument for trim function: expected a string")
-        return val.strip()

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

@@ -1,47 +0,0 @@
-"""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) -> 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):
-            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

@@ -1,24 +0,0 @@
-"""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) -> None:
-        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

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

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

@@ -1,28 +0,0 @@
-"""Represents a CASE expression in the AST."""
-
-from typing import Any
-
-from ..ast_node import ASTNode
-from .when import When
-
-
-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

@@ -1,12 +0,0 @@
-"""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

@@ -1,8 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-"""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) -> Any:
-        return self.get_children()[0].value()

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

@@ -1,46 +0,0 @@
-"""Operations module for FlowQuery parsing."""
-
-from .aggregated_return import AggregatedReturn
-from .aggregated_with import AggregatedWith
-from .call import Call
-from .create_node import CreateNode
-from .create_relationship import CreateRelationship
-from .delete_node import DeleteNode
-from .delete_relationship import DeleteRelationship
-from .group_by import GroupBy
-from .limit import Limit
-from .load import Load
-from .match import Match
-from .operation import Operation
-from .order_by import OrderBy, SortField
-from .projection import Projection
-from .return_op import Return
-from .union import Union
-from .union_all import UnionAll
-from .unwind import Unwind
-from .where import Where
-from .with_op import With
-
-__all__ = [
-    "Operation",
-    "Projection",
-    "Return",
-    "With",
-    "Unwind",
-    "Load",
-    "Where",
-    "Limit",
-    "AggregatedReturn",
-    "AggregatedWith",
-    "Call",
-    "GroupBy",
-    "Match",
-    "CreateNode",
-    "CreateRelationship",
-    "DeleteNode",
-    "DeleteRelationship",
-    "Union",
-    "UnionAll",
-    "OrderBy",
-    "SortField",
-]

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

@@ -1,25 +0,0 @@
-from typing import Any, Dict, List
-
-from ..ast_node import ASTNode
-from .group_by import GroupBy
-from .return_op import Return
-
-
-class AggregatedReturn(Return):
-    """Represents an aggregated RETURN operation that groups and reduces values."""
-
-    def __init__(self, expressions: List[ASTNode]) -> None:
-        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
-        results = list(self._group_by.generate_results())
-        if self._order_by is not None:
-            results = self._order_by.sort(results)
-        return results

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

@@ -1,22 +0,0 @@
-from typing import List
-
-from ..ast_node import ASTNode
-from .group_by import GroupBy
-from .return_op import Return
-
-
-class AggregatedWith(Return):
-    """Represents an aggregated WITH operation that groups and reduces values."""
-
-    def __init__(self, expressions: List[ASTNode]) -> None:
-        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

@@ -1,73 +0,0 @@
-"""Represents a CALL operation for invoking async functions."""
-
-from typing import Any, Dict, List, Optional
-
-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) -> None:
-        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[ASTNode]:
-        return self.children
-
-    @yielded.setter
-    def yielded(self, expressions: List[ASTNode]) -> None:
-        self.children = expressions
-        self._map.set_map(expressions)  # ExpressionMap accepts list of 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

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

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

@@ -1,35 +0,0 @@
-"""Represents a CREATE operation for creating virtual relationships."""
-
-from typing import Any, Dict, List
-
-from ...graph.database import Database
-from ...graph.relationship import Relationship
-from ..ast_node import ASTNode
-from .operation import Operation
-
-
-class CreateRelationship(Operation):
-    """Represents a CREATE operation for creating virtual relationships."""
-
-    def __init__(self, relationship: Relationship, statement: ASTNode) -> None:
-        super().__init__()
-        self._relationship = relationship
-        self._statement = statement
-
-    @property
-    def relationship(self) -> Relationship:
-        return self._relationship
-
-    @property
-    def statement(self) -> ASTNode:
-        return self._statement
-
-    async def run(self) -> None:
-        if self._relationship is None:
-            raise ValueError("Relationship is null")
-        db = Database.get_instance()
-        db.add_relationship(self._relationship, self._statement)
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        return []

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

@@ -1,29 +0,0 @@
-"""Represents a DELETE operation for deleting virtual nodes."""
-
-from typing import Any, Dict, List
-
-from ...graph.database import Database
-from ...graph.node import Node
-from .operation import Operation
-
-
-class DeleteNode(Operation):
-    """Represents a DELETE operation for deleting virtual nodes."""
-
-    def __init__(self, node: Node) -> None:
-        super().__init__()
-        self._node = node
-
-    @property
-    def node(self) -> Node:
-        return self._node
-
-    async def run(self) -> None:
-        if self._node is None:
-            raise ValueError("Node is null")
-        db = Database.get_instance()
-        db.remove_node(self._node)
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        return []

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

@@ -1,29 +0,0 @@
-"""Represents a DELETE operation for deleting virtual relationships."""
-
-from typing import Any, Dict, List
-
-from ...graph.database import Database
-from ...graph.relationship import Relationship
-from .operation import Operation
-
-
-class DeleteRelationship(Operation):
-    """Represents a DELETE operation for deleting virtual relationships."""
-
-    def __init__(self, relationship: Relationship) -> None:
-        super().__init__()
-        self._relationship = relationship
-
-    @property
-    def relationship(self) -> Relationship:
-        return self._relationship
-
-    async def run(self) -> None:
-        if self._relationship is None:
-            raise ValueError("Relationship is null")
-        db = Database.get_instance()
-        db.remove_relationship(self._relationship)
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        return []