flowquery 1.0.46 → 1.0.48

package/flowquery-py/setup_env.sh

@@ -1,87 +0,0 @@
-#!/bin/bash
-# FlowQuery Python Environment Setup Script for Linux/macOS
-# This script creates a conda environment for FlowQuery development
-
-echo "========================================"
-echo "FlowQuery Python Environment Setup"
-echo "========================================"
-echo
-
-# Check if conda is available
-if ! command -v conda &> /dev/null; then
-    echo "ERROR: Conda is not installed or not in PATH."
-    echo "Please install Anaconda or Miniconda first."
-    exit 1
-fi
-
-# Set environment name
-ENV_NAME="flowquery"
-
-# Get Python version from pyproject.toml
-PYTHON_VERSION=$(grep -oP 'requires-python\s*=\s*">=\K[0-9.]+' pyproject.toml 2>/dev/null || echo "3.10")
-echo "Using Python version: $PYTHON_VERSION"
-
-# Check if environment already exists
-if conda env list | grep -q "^${ENV_NAME} "; then
-    echo "Environment '${ENV_NAME}' already exists."
-    read -p "Do you want to recreate it? (y/n): " RECREATE
-    if [[ "$RECREATE" =~ ^[Yy]$ ]]; then
-        echo "Removing existing environment..."
-        conda env remove -n "$ENV_NAME" -y
-    else
-        echo "Keeping existing environment..."
-        echo
-        echo "========================================"
-        echo "Environment ready!"
-        echo "========================================"
-        echo
-        echo "To activate the environment, run:"
-        echo "    conda activate $ENV_NAME"
-        echo
-        echo "To run tests:"
-        echo "    pytest tests/"
-        echo
-        echo "To deactivate when done:"
-        echo "    conda deactivate"
-        exit 0
-    fi
-fi
-
-# Create the environment
-echo
-echo "Creating conda environment '${ENV_NAME}' with Python ${PYTHON_VERSION}..."
-conda create -n "$ENV_NAME" python="$PYTHON_VERSION" pip -y
-
-if [ $? -ne 0 ]; then
-    echo
-    echo "ERROR: Failed to create conda environment."
-    exit 1
-fi
-
-# Activate and install package in dev mode
-echo
-echo "Installing package in development mode..."
-source "$(conda info --base)/etc/profile.d/conda.sh"
-conda activate "$ENV_NAME"
-pip install -e ".[dev]"
-
-if [ $? -ne 0 ]; then
-    echo
-    echo "ERROR: Failed to install package."
-    exit 1
-fi
-
-echo
-echo "========================================"
-echo "Environment created successfully!"
-echo "========================================"
-echo
-echo "To activate the environment, run:"
-echo "    conda activate $ENV_NAME"
-echo
-echo "To run tests:"
-echo "    pytest tests/"
-echo
-echo "To deactivate when done:"
-echo "    conda deactivate"
-echo

package/flowquery-py/src/__init__.py

@@ -1,38 +0,0 @@
-"""
-FlowQuery - A declarative query language for data processing pipelines.
-
-This is the Python implementation of FlowQuery.
-
-This module provides the core components for defining, parsing, and executing FlowQuery queries.
-"""
-
-from .compute.flowquery import FlowQuery
-from .compute.runner import Runner
-from .io.command_line import CommandLine
-from .parsing.functions.aggregate_function import AggregateFunction
-from .parsing.functions.async_function import AsyncFunction
-from .parsing.functions.function import Function
-from .parsing.functions.function_metadata import (
-    FunctionCategory,
-    FunctionDef,
-    FunctionMetadata,
-)
-from .parsing.functions.predicate_function import PredicateFunction
-from .parsing.functions.reducer_element import ReducerElement
-from .parsing.parser import Parser
-
-__all__ = [
-    "FlowQuery",
-    "Runner",
-    "CommandLine",
-    "Parser",
-    "Function",
-    "AggregateFunction",
-    "AsyncFunction",
-    "PredicateFunction",
-    "ReducerElement",
-    "FunctionDef",
-    "FunctionMetadata",
-    "FunctionCategory",
-]
-

package/flowquery-py/src/__main__.py

@@ -1,10 +0,0 @@
-#!/usr/bin/env python
-"""FlowQuery command-line entry point.
-
-Run with: python -m src
-"""
-
-from . import CommandLine
-
-if __name__ == "__main__":
-    CommandLine().loop()

package/flowquery-py/src/compute/__init__.py

@@ -1,6 +0,0 @@
-"""Compute module for FlowQuery."""
-
-from .flowquery import FlowQuery
-from .runner import Runner
-
-__all__ = ["FlowQuery", "Runner"]

package/flowquery-py/src/compute/flowquery.py

@@ -1,68 +0,0 @@
-"""FlowQuery public API surface.
-
-Extends Runner with extensibility features such as function listing
-and plugin registration, keeping the Runner focused on execution.
-"""
-
-from typing import List, Optional, Type
-
-from ..parsing.functions.function import Function
-from ..parsing.functions.function_factory import FunctionFactory
-from ..parsing.functions.function_metadata import (
-    FunctionMetadata,
-    get_function_metadata,
-)
-from .runner import Runner
-
-
-class FlowQuery(Runner):
-    """FlowQuery is the public API surface for the FlowQuery library.
-
-    It extends Runner with convenience class methods for function
-    introspection and plugin registration.
-
-    Example:
-        fq = FlowQuery("WITH 1 as x RETURN x")
-        await fq.run()
-        print(fq.results)  # [{'x': 1}]
-
-        # List all registered functions
-        functions = FlowQuery.list_functions()
-    """
-
-    #: Base Function class for creating custom plugin functions.
-    Function: Type[Function] = Function
-
-    @staticmethod
-    def list_functions(
-        category: Optional[str] = None,
-        async_only: bool = False,
-        sync_only: bool = False,
-    ) -> List[FunctionMetadata]:
-        """List all registered functions with their metadata.
-
-        Args:
-            category: Optional category filter
-            async_only: If True, return only async functions
-            sync_only: If True, return only sync functions
-
-        Returns:
-            List of function metadata
-        """
-        return FunctionFactory.list_functions(
-            category=category,
-            async_only=async_only,
-            sync_only=sync_only,
-        )
-
-    @staticmethod
-    def get_function_metadata(name: str) -> Optional[FunctionMetadata]:
-        """Get metadata for a specific function.
-
-        Args:
-            name: The function name
-
-        Returns:
-            Function metadata or None
-        """
-        return get_function_metadata(name.lower())

package/flowquery-py/src/compute/runner.py

@@ -1,64 +0,0 @@
-"""Executes a FlowQuery statement and retrieves the results."""
-
-from typing import Any, Dict, List, Optional
-
-from ..parsing.ast_node import ASTNode
-from ..parsing.operations.operation import Operation
-from ..parsing.parser import Parser
-
-
-class Runner:
-    """Executes a FlowQuery statement and retrieves the results.
-
-    The Runner class parses a FlowQuery statement into an AST and executes it,
-    managing the execution flow from the first operation to the final return statement.
-
-    Example:
-        runner = Runner("WITH 1 as x RETURN x")
-        await runner.run()
-        print(runner.results)  # [{ x: 1 }]
-    """
-
-    def __init__(
-        self,
-        statement: Optional[str] = None,
-        ast: Optional[ASTNode] = None
-    ):
-        """Creates a new Runner instance and parses the FlowQuery statement.
-
-        Args:
-            statement: The FlowQuery statement to execute
-            ast: An already-parsed AST (optional)
-
-        Raises:
-            ValueError: If neither statement nor AST is provided
-        """
-        if (statement is None or statement == "") and ast is None:
-            raise ValueError("Either statement or AST must be provided")
-
-        _ast = ast if ast is not None else Parser().parse(statement or "")
-        first = _ast.first_child()
-        last = _ast.last_child()
-        if not isinstance(first, Operation) or not isinstance(last, Operation):
-            raise ValueError("AST must contain Operations")
-        self._first: Operation = first
-        self._last: Operation = last
-
-    async def run(self) -> None:
-        """Executes the parsed FlowQuery statement.
-
-        Raises:
-            Exception: If an error occurs during execution
-        """
-        await self._first.initialize()
-        await self._first.run()
-        await self._first.finish()
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        """Gets the results from the executed statement.
-
-        Returns:
-            The results from the last operation (typically a RETURN statement)
-        """
-        return self._last.results

package/flowquery-py/src/extensibility.py

@@ -1,52 +0,0 @@
-"""FlowQuery Extensibility API
-
-This module provides all the exports needed to create custom FlowQuery functions.
-
-Example:
-    from flowquery.extensibility import Function, FunctionDef
-
-    @FunctionDef({
-        'description': "Converts a string to uppercase",
-        'category': "string",
-        'parameters': [{'name': "text", 'description': "String to convert", 'type': "string"}],
-        'output': {'description': "Uppercase string", 'type': "string"}
-    })
-    class UpperCase(Function):
-        def __init__(self):
-            super().__init__("uppercase")
-            self._expected_parameter_count = 1
-
-        def value(self) -> str:
-            return str(self.get_children()[0].value()).upper()
-"""
-
-# Base function classes for creating custom functions
-from .parsing.functions.aggregate_function import AggregateFunction
-from .parsing.functions.async_function import AsyncFunction
-from .parsing.functions.function import Function
-
-# Decorator and metadata types for function registration
-from .parsing.functions.function_metadata import (
-    FunctionCategory,
-    FunctionDef,
-    FunctionDefOptions,
-    FunctionMetadata,
-    OutputSchema,
-    ParameterSchema,
-)
-from .parsing.functions.predicate_function import PredicateFunction
-from .parsing.functions.reducer_element import ReducerElement
-
-__all__ = [
-    "Function",
-    "AggregateFunction",
-    "AsyncFunction",
-    "PredicateFunction",
-    "ReducerElement",
-    "FunctionDef",
-    "FunctionMetadata",
-    "FunctionDefOptions",
-    "ParameterSchema",
-    "OutputSchema",
-    "FunctionCategory",
-]

package/flowquery-py/src/graph/__init__.py

@@ -1,31 +0,0 @@
-"""Graph module for FlowQuery."""
-
-from .database import Database
-from .hops import Hops
-from .node import Node
-from .node_data import NodeData
-from .node_reference import NodeReference
-from .pattern import Pattern
-from .pattern_expression import PatternExpression
-from .patterns import Patterns
-from .physical_node import PhysicalNode
-from .physical_relationship import PhysicalRelationship
-from .relationship import Relationship
-from .relationship_data import RelationshipData
-from .relationship_reference import RelationshipReference
-
-__all__ = [
-    "Node",
-    "Relationship",
-    "Pattern",
-    "Patterns",
-    "PatternExpression",
-    "Database",
-    "Hops",
-    "NodeData",
-    "NodeReference",
-    "RelationshipData",
-    "RelationshipReference",
-    "PhysicalNode",
-    "PhysicalRelationship",
-]

package/flowquery-py/src/graph/data.py

@@ -1,136 +0,0 @@
-"""Data class for graph record iteration and indexing."""
-
-from typing import Any, Dict, List, Optional
-
-
-class IndexEntry:
-    """Index entry for tracking positions of records with a specific key value."""
-
-    def __init__(self, positions: Optional[List[int]] = None):
-        self._positions: List[int] = positions if positions is not None else []
-        self._index: int = -1
-
-    def add(self, position: int) -> None:
-        """Add a position to the index entry."""
-        self._positions.append(position)
-
-    @property
-    def position(self) -> int:
-        """Get the current position."""
-        return self._positions[self._index]
-
-    def reset(self) -> None:
-        """Reset the index to the beginning."""
-        self._index = -1
-
-    def next(self) -> bool:
-        """Move to the next position. Returns True if successful."""
-        if self._index < len(self._positions) - 1:
-            self._index += 1
-            return True
-        return False
-
-    def clone(self) -> "IndexEntry":
-        """Create a copy of this index entry."""
-        return IndexEntry(list(self._positions))
-
-
-class Layer:
-    """Layer for managing index state at a specific level."""
-
-    def __init__(self, indexes: Dict[str, Dict[str, IndexEntry]]):
-        self._indexes: Dict[str, Dict[str, IndexEntry]] = indexes
-        self._current: int = -1
-
-    def index(self, name: str) -> Dict[str, IndexEntry]:
-        """Get or create an index by name."""
-        if name not in self._indexes:
-            self._indexes[name] = {}
-        return self._indexes[name]
-
-    @property
-    def indexes(self) -> Dict[str, Dict[str, IndexEntry]]:
-        """Get all indexes."""
-        return self._indexes
-
-    @property
-    def current(self) -> int:
-        """Get the current position."""
-        return self._current
-
-    @current.setter
-    def current(self, value: int) -> None:
-        """Set the current position."""
-        self._current = value
-
-
-class Data:
-    """Base class for graph data with record iteration and indexing."""
-
-    def __init__(self, records: Optional[List[Dict[str, Any]]] = None):
-        self._records: List[Dict[str, Any]] = records if records is not None else []
-        self._layers: Dict[int, Layer] = {0: Layer({})}
-
-    def _build_index(self, key: str, level: int = 0) -> None:
-        """Build an index for the given key at the specified level."""
-        idx = self.layer(level).index(key)
-        idx.clear()
-        for i, record in enumerate(self._records):
-            if key in record:
-                if record[key] not in idx:
-                    idx[record[key]] = IndexEntry()
-                idx[record[key]].add(i)
-
-    def layer(self, level: int = 0) -> Layer:
-        """Get or create a layer at the specified level."""
-        if level not in self._layers:
-            first = self._layers[0]
-            cloned_indexes = {}
-            for name, index_map in first.indexes.items():
-                cloned_map = {}
-                for key, entry in index_map.items():
-                    cloned_map[key] = entry.clone()
-                cloned_indexes[name] = cloned_map
-            self._layers[level] = Layer(cloned_indexes)
-        return self._layers[level]
-
-    def _find(self, key: str, level: int = 0, index_name: Optional[str] = None) -> bool:
-        """Find the next record with the given key value."""
-        idx: Optional[Dict[str, IndexEntry]] = None
-        if index_name:
-            idx = self.layer(level).index(index_name)
-        else:
-            indexes = self.layer(level).indexes
-            idx = next(iter(indexes.values())) if indexes else None
-        if not idx or key not in idx:
-            self.layer(level).current = len(self._records)  # Move to end
-            return False
-        else:
-            entry = idx[key]
-            more = entry.next()
-            if not more:
-                self.layer(level).current = len(self._records)  # Move to end
-                return False
-            self.layer(level).current = entry.position
-            return True
-
-    def reset(self) -> None:
-        """Reset iteration to the beginning."""
-        for layer in self._layers.values():
-            layer.current = -1
-            for index_map in layer.indexes.values():
-                for entry in index_map.values():
-                    entry.reset()
-
-    def next(self, level: int = 0) -> bool:
-        """Move to the next record. Returns True if successful."""
-        if self.layer(level).current < len(self._records) - 1:
-            self.layer(level).current += 1
-            return True
-        return False
-
-    def current(self, level: int = 0) -> Optional[Dict[str, Any]]:
-        """Get the current record."""
-        if self.layer(level).current < len(self._records):
-            return self._records[self.layer(level).current]
-        return None

package/flowquery-py/src/graph/database.py

@@ -1,141 +0,0 @@
-"""Graph database for FlowQuery."""
-
-from __future__ import annotations
-
-from typing import Any, AsyncIterator, Dict, List, Optional, Union
-
-from ..parsing.ast_node import ASTNode
-from .node import Node
-from .node_data import NodeData
-from .physical_node import PhysicalNode
-from .physical_relationship import PhysicalRelationship
-from .relationship import Relationship
-from .relationship_data import RelationshipData
-
-
-class Database:
-    """Singleton database for storing graph data."""
-
-    _instance: Optional['Database'] = None
-    _nodes: Dict[str, 'PhysicalNode'] = {}
-    _relationships: Dict[str, 'PhysicalRelationship'] = {}
-
-    def __init__(self) -> None:
-        pass
-
-    @classmethod
-    def get_instance(cls) -> 'Database':
-        if cls._instance is None:
-            cls._instance = Database()
-        return cls._instance
-
-    def add_node(self, node: 'Node', statement: ASTNode) -> None:
-        """Adds a node to the database."""
-        if node.label is None:
-            raise ValueError("Node label is null")
-        physical = PhysicalNode(None, node.label)
-        physical.statement = statement
-        Database._nodes[node.label] = physical
-
-    def remove_node(self, node: 'Node') -> None:
-        """Removes a node from the database."""
-        if node.label is None:
-            raise ValueError("Node label is null")
-        Database._nodes.pop(node.label, None)
-
-    def get_node(self, node: 'Node') -> Optional['PhysicalNode']:
-        """Gets a node from the database."""
-        return Database._nodes.get(node.label) if node.label else None
-
-    def add_relationship(self, relationship: 'Relationship', statement: ASTNode) -> None:
-        """Adds a relationship to the database."""
-        if relationship.type is None:
-            raise ValueError("Relationship type is null")
-        physical = PhysicalRelationship()
-        physical.type = relationship.type
-        physical.statement = statement
-        if relationship.source is not None:
-            physical.source = relationship.source
-        if relationship.target is not None:
-            physical.target = relationship.target
-        Database._relationships[relationship.type] = physical
-
-    def remove_relationship(self, relationship: 'Relationship') -> None:
-        """Removes a relationship from the database."""
-        if relationship.type is None:
-            raise ValueError("Relationship type is null")
-        Database._relationships.pop(relationship.type, None)
-
-    def get_relationship(self, relationship: 'Relationship') -> Optional['PhysicalRelationship']:
-        """Gets a relationship from the database."""
-        return Database._relationships.get(relationship.type) if relationship.type else None
-
-    def get_relationships(self, relationship: 'Relationship') -> list['PhysicalRelationship']:
-        """Gets multiple physical relationships for ORed types."""
-        result = []
-        for rel_type in relationship.types:
-            physical = Database._relationships.get(rel_type)
-            if physical:
-                result.append(physical)
-        return result
-
-    async def schema(self) -> List[Dict[str, Any]]:
-        """Returns the graph schema with node/relationship labels and sample data."""
-        return [item async for item in self._schema()]
-
-    async def _schema(self) -> AsyncIterator[Dict[str, Any]]:
-        """Async generator for graph schema with node/relationship labels and sample data."""
-        for label, physical_node in Database._nodes.items():
-            records = await physical_node.data()
-            entry: Dict[str, Any] = {"kind": "Node", "label": label}
-            if records:
-                sample = {k: v for k, v in records[0].items() if k != "id"}
-                properties = list(sample.keys())
-                if properties:
-                    entry["properties"] = properties
-                    entry["sample"] = sample
-            yield entry
-
-        for rel_type, physical_rel in Database._relationships.items():
-            records = await physical_rel.data()
-            entry_rel: Dict[str, Any] = {
-                "kind": "Relationship",
-                "type": rel_type,
-                "from_label": physical_rel.source.label if physical_rel.source else None,
-                "to_label": physical_rel.target.label if physical_rel.target else None,
-            }
-            if records:
-                sample = {k: v for k, v in records[0].items() if k not in ("left_id", "right_id")}
-                properties = list(sample.keys())
-                if properties:
-                    entry_rel["properties"] = properties
-                    entry_rel["sample"] = sample
-            yield entry_rel
-
-    async def get_data(self, element: Union['Node', 'Relationship']) -> Union['NodeData', 'RelationshipData']:
-        """Gets data for a node or relationship."""
-        if isinstance(element, Node):
-            node = self.get_node(element)
-            if node is None:
-                raise ValueError(f"Physical node not found for label {element.label}")
-            data = await node.data()
-            return NodeData(data)
-        elif isinstance(element, Relationship):
-            if len(element.types) > 1:
-                physicals = self.get_relationships(element)
-                if not physicals:
-                    raise ValueError(f"No physical relationships found for types {', '.join(element.types)}")
-                all_records = []
-                for i, physical in enumerate(physicals):
-                    records = await physical.data()
-                    type_name = element.types[i]
-                    for record in records:
-                        all_records.append({**record, "_type": type_name})
-                return RelationshipData(all_records)
-            relationship = self.get_relationship(element)
-            if relationship is None:
-                raise ValueError(f"Physical relationship not found for type {element.type}")
-            data = await relationship.data()
-            return RelationshipData(data)
-        else:
-            raise ValueError("Element is neither Node nor Relationship")

package/flowquery-py/src/graph/hops.py

@@ -1,43 +0,0 @@
-"""Hops specification for variable-length relationships."""
-
-import sys
-from typing import Optional
-
-
-class Hops:
-    """Specifies the number of hops for a relationship pattern."""
-
-    def __init__(self, min_hops: Optional[int] = None, max_hops: Optional[int] = None):
-        # Default min=0, max=1 (matching TypeScript implementation)
-        if min_hops is None:
-            self._min: int = 0
-        else:
-            self._min = min_hops
-        if max_hops is None:
-            self._max: int = 1
-        else:
-            self._max = max_hops
-
-    @property
-    def min(self) -> int:
-        return self._min
-
-    @min.setter
-    def min(self, value: int) -> None:
-        self._min = value
-
-    @property
-    def max(self) -> int:
-        return self._max
-
-    @max.setter
-    def max(self, value: int) -> None:
-        self._max = value
-
-    def multi(self) -> bool:
-        """Returns True if this represents a variable-length relationship."""
-        return self._max > 1 or self._max == -1 or self._max == sys.maxsize
-
-    def unbounded(self) -> bool:
-        """Returns True if the max is unbounded."""
-        return self._max == sys.maxsize