flowquery 1.0.46 → 1.0.48

package/flowquery-py/notebooks/TestFlowQuery.ipynb

@@ -1,440 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%reload_ext autoreload\n",
-    "%autoreload 2\n",
-    "\n",
-    "from flowquery import Runner"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1",
-   "metadata": {},
-   "source": [
-    "Create virtual node test"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query: str = \"\"\"\n",
-    "    create virtual (:Fact) as {\n",
-    "        unwind range(0,6) as i\n",
-    "        load json from \"https://catfact.ninja/fact\" as item\n",
-    "        return i as id, item.fact\n",
-    "    }\n",
-    "\"\"\"\n",
-    "\n",
-    "runner: Runner = Runner(query)\n",
-    "await runner.run()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3",
-   "metadata": {},
-   "source": [
-    "Query virtual graph node"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "runner: Runner = Runner(\"match (n:Fact) return n\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5",
-   "metadata": {},
-   "source": [
-    "Test extensibility"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from flowquery.extensibility import (\n",
-    "    Function,\n",
-    "    FunctionDef,\n",
-    "    AggregateFunction,\n",
-    "    ReducerElement,\n",
-    "    AsyncFunction,\n",
-    "    PredicateFunction\n",
-    ")\n",
-    "import aiohttp\n",
-    "import json\n",
-    "from typing import Any, List, Iterator, Union, Dict\n",
-    "\n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Converts a string to uppercase\",\n",
-    "    \"category\": \"string\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"text\", \"description\": \"String to convert\", \"type\": \"string\"}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"Uppercase string\", \"type\": \"string\"}\n",
-    "})\n",
-    "class UpperCase(Function):\n",
-    "    def __init__(self):\n",
-    "        super().__init__(\"uppercase\")\n",
-    "        self._expected_parameter_count = 1\n",
-    "\n",
-    "    def value(self) -> str:\n",
-    "        return str(self.get_children()[0].value()).upper()\n",
-    "    \n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Extracts nodes from a collection\",\n",
-    "    \"category\": \"scalar\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"collection\", \"description\": \"Collection to extract nodes from\", \"type\": \"any[]\"}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"List of nodes extracted from the collection\", \"type\": \"node[]\"}\n",
-    "})\n",
-    "class Nodes(Function):\n",
-    "    def __init__(self):\n",
-    "        super().__init__(\"nodes\")\n",
-    "        self._expected_parameter_count = 1\n",
-    "\n",
-    "    def value(self) -> List[Dict[str, Any]]:\n",
-    "        pattern: List[Dict[str, Any]] = self.get_children()[0].value()\n",
-    "        return list(self._nodes(pattern))\n",
-    "\n",
-    "    def _nodes(self, pattern: List[Dict[str, Any]]) -> Iterator[Dict[str, Any]]:\n",
-    "        for element in pattern:\n",
-    "            if isinstance(element, dict) and \"id\" in element:\n",
-    "                yield element\n",
-    "    \n",
-    "\n",
-    "class ProductElement(ReducerElement):\n",
-    "    def __init__(self):\n",
-    "        self._value: float = 1.0\n",
-    "\n",
-    "    @property\n",
-    "    def value(self) -> float:\n",
-    "        return self._value\n",
-    "\n",
-    "    @value.setter\n",
-    "    def value(self, v: float) -> None:\n",
-    "        self._value = v\n",
-    "    \n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Calculates the product of a list of numbers\",\n",
-    "    \"category\": \"aggregate\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"numbers\", \"description\": \"List of numbers to multiply\", \"type\": \"number[]\"}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"Product of the numbers\", \"type\": \"number\"}\n",
-    "})\n",
-    "class Product(AggregateFunction):\n",
-    "    def __init__(self):\n",
-    "        super().__init__(\"product\")\n",
-    "\n",
-    "    def reduce(self, element: ReducerElement) -> None:\n",
-    "        element.value *= self.first_child().value()\n",
-    "\n",
-    "    def element(self) -> ReducerElement:\n",
-    "        return ProductElement()\n",
-    "\n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Asynchronous function that fetches data from a URL\",\n",
-    "    \"category\": \"async\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"url\", \"description\": \"URL to fetch data from\", \"type\": \"string\"}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"Fetched data\", \"type\": \"string\"}\n",
-    "})\n",
-    "class get(AsyncFunction):\n",
-    "    async def generate(self, url: str):\n",
-    "        async with aiohttp.ClientSession() as session:\n",
-    "            async with session.get(url) as response:\n",
-    "                yield await response.json()\n",
-    "\n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Fetch json data from a file path\",\n",
-    "    \"category\": \"async\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"path\", \"description\": \"File path to fetch data from\", \"type\": \"string\"}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"Fetched data\", \"type\": \"string\"}\n",
-    "})\n",
-    "class json_file(AsyncFunction):\n",
-    "    async def generate(self, path: str):\n",
-    "        with open(path, \"r\") as file:\n",
-    "            yield json.load(file)\n",
-    "\n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Extracts values from an array with optional filtering. Uses list comprehension syntax: extract(variable IN array [WHERE condition] | expression)\",\n",
-    "    \"category\": \"predicate\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"variable\", \"description\": \"Variable name to bind each element\", \"type\": \"string\"},\n",
-    "        {\"name\": \"array\", \"description\": \"Array to iterate over\", \"type\": \"array\"},\n",
-    "        {\"name\": \"expression\", \"description\": \"Expression to return for each element\", \"type\": \"any\"},\n",
-    "        {\"name\": \"where\", \"description\": \"Optional filter condition\", \"type\": \"boolean\", \"required\": False}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"Extracted values from the array after applying the optional filter\", \"type\": \"array\", \"example\": [2, 4]},\n",
-    "    \"examples\": [\n",
-    "        \"WITH [1, 2, 3] AS nums RETURN extract(n IN nums | n)\",\n",
-    "        \"WITH [1, 2, 3, 4] AS nums RETURN extract(n IN nums WHERE n > 1 | n * 2)\"\n",
-    "    ]\n",
-    "})\n",
-    "class PredicateExtract(PredicateFunction):\n",
-    "    \"\"\"PredicateExtract function.\n",
-    "    \n",
-    "    Extracts values from an array with optional filtering.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def __init__(self):\n",
-    "        super().__init__(\"extract\")\n",
-    "\n",
-    "    def value(self) -> List[Any]:\n",
-    "        return list(self._extract())\n",
-    "    \n",
-    "    def _extract(self) -> Iterator[Any]:\n",
-    "        self.reference.referred = self._value_holder\n",
-    "        array = self.array.value()\n",
-    "        if array is None or not isinstance(array, list):\n",
-    "            raise ValueError(\"Invalid array for extract function\")\n",
-    "        \n",
-    "        for item in array:\n",
-    "            self._value_holder.holder = item\n",
-    "            if self.where is None or self.where.value():\n",
-    "                yield self._return.value()\n",
-    "\n",
-    "@FunctionDef({\n",
-    "    \"description\": \"Checks if any element in the array satisfies the condition. Uses list comprehension syntax: any(variable IN array [WHERE condition])\",\n",
-    "    \"category\": \"predicate\",\n",
-    "    \"parameters\": [\n",
-    "        {\"name\": \"variable\", \"description\": \"Variable name to bind each element\", \"type\": \"string\"},\n",
-    "        {\"name\": \"array\", \"description\": \"Array to iterate over\", \"type\": \"array\"},\n",
-    "        {\"name\": \"where\", \"description\": \"Condition to check for each element\", \"type\": \"boolean\", \"required\": False}\n",
-    "    ],\n",
-    "    \"output\": {\"description\": \"True if any element satisfies the condition, otherwise false\", \"type\": \"boolean\", \"example\": True},\n",
-    "    \"examples\": [\n",
-    "        \"WITH [1, 2, 3] AS nums RETURN any(n IN nums | n > 2)\",\n",
-    "        \"WITH [1, 2, 3] AS nums RETURN any(n IN nums | n > 5)\"\n",
-    "    ]\n",
-    "})\n",
-    "class Any(PredicateFunction):\n",
-    "    \"\"\"Any function.\n",
-    "    \n",
-    "    Returns true if any element in the array satisfies the condition.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def __init__(self):\n",
-    "        super().__init__(\"any\")\n",
-    "\n",
-    "    def value(self) -> bool:\n",
-    "        return any(self._any())\n",
-    "    \n",
-    "    def _any(self) -> Iterator[bool]:\n",
-    "        self.reference.referred = self._value_holder\n",
-    "        array = self.array.value()\n",
-    "        if array is None or not isinstance(array, list):\n",
-    "            raise ValueError(\"Invalid array for any function\")\n",
-    "        \n",
-    "        for item in array:\n",
-    "            self._value_holder.holder = item\n",
-    "            if self.where is None or self.where.value():\n",
-    "                yield True"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7",
-   "metadata": {},
-   "source": [
-    "Test functions just created"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "runner: Runner = Runner(\"\"\"\n",
-    "    return uppercase(\"hello world\") as uppercased\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)\n",
-    "\n",
-    "runner: Runner = Runner(\"\"\"\n",
-    "    unwind [1, 2, 3, 4, 5] as num\n",
-    "    return product(num) as total_product\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)\n",
-    "\n",
-    "runner: Runner = Runner(\"\"\"\n",
-    "    load json from get(\"https://catfact.ninja/fact\") as result\n",
-    "    return result.fact as cat_fact\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)\n",
-    "\n",
-    "runner: Runner = Runner(\"\"\"\n",
-    "    load json from json_file(\"../misc/data/test.json\") as result\n",
-    "    unwind result as entry\n",
-    "    return entry\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)\n",
-    "\n",
-    "runner: Runner = Runner(\"\"\"\n",
-    "    with [\n",
-    "        {\"age\": 25, \"name\": \"Alice\"},\n",
-    "        {\"age\": 30, \"name\": \"Bob\"},\n",
-    "        {\"age\": 22, \"name\": \"Charlie\"},\n",
-    "        {\"age\": 28, \"name\": \"Diana\"}\n",
-    "    ] as people\n",
-    "    return extract(p IN people | p.name WHERE p.age > 25) as names_over_25\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)\n",
-    "\n",
-    "runner: Runner = Runner(\"\"\"\n",
-    "    with [1, 2, 3, 4, 5] as numbers\n",
-    "    return any(n IN numbers | n where n > 6) as has_greater_than_3\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9",
-   "metadata": {},
-   "source": [
-    "List functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "10",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "runner: Runner = Runner(\"\"\"\n",
-    "    unwind functions() as func\n",
-    "    return func\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "for record in runner.results:\n",
-    "    print(record)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "11",
-   "metadata": {},
-   "source": [
-    "Test virtual graph"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "12",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await Runner(\"\"\"\n",
-    "    create virtual (:User) as {\n",
-    "        load json from json_file(\n",
-    "            \"../misc/data/users.json\"\n",
-    "        ) as users\n",
-    "        unwind users as user\n",
-    "        return user.id as id,\n",
-    "            user.name as name,\n",
-    "            user.title as title,\n",
-    "            user.department as department,\n",
-    "            user.email as email,\n",
-    "            user.managerId as managerId\n",
-    "    }\n",
-    "\"\"\").run()\n",
-    "\n",
-    "await Runner(\"\"\"\n",
-    "    create virtual (:User)-[:MANAGED_BY]->(:User) as {\n",
-    "        load json from json_file(\n",
-    "            \"../misc/data/users.json\"\n",
-    "        ) as users\n",
-    "        unwind users as user\n",
-    "        return user.id as left_id, user.managerId as right_id\n",
-    "    }\n",
-    "\"\"\").run()\n",
-    "\n",
-    "runner: Runner = Runner(\"\"\"\n",
-    "    MATCH p=(u:User)-[:MANAGED_BY*]->(ceo:User)\n",
-    "    WHERE NOT (ceo)-[:MANAGED_BY]->(:User)\n",
-    "    and any(n IN nodes(p) | n where n.department = \"Litigation\")\n",
-    "    RETURN\n",
-    "        u.name as employee,\n",
-    "        extract(n IN nodes(p) | n.name) as management_chain\n",
-    "\"\"\")\n",
-    "await runner.run()\n",
-    "print(f\"Total results: {len(runner.results)}\")\n",
-    "for record in runner.results:\n",
-    "    print(record)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "13",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "flowquery",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.19"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

package/flowquery-py/pyproject.toml

@@ -1,121 +0,0 @@
-[project]
-name = "flowquery"
-version = "1.0.36"
-description = "A declarative query language for data processing pipelines"
-readme = "README.md"
-requires-python = ">=3.10"
-license = {text = "MIT"}
-authors = [
-    {name = "FlowQuery Contributors"}
-]
-keywords = ["query", "data-processing", "pipeline", "declarative"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Database :: Front-Ends",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-]
-dependencies = [
-    "aiohttp>=3.8.0",
-]
-
-[project.scripts]
-flowquery = "flowquery.io.command_line:main"
-
-[project.urls]
-Homepage = "https://github.com/microsoft/FlowQuery/flowquery-py"
-Repository = "https://github.com/microsoft/FlowQuery/flowquery-py"
-Documentation = "https://github.com/microsoft/FlowQuery/flowquery-py#readme"
-Issues = "https://github.com/microsoft/FlowQuery/issues"
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=7.0.0",
-    "pytest-asyncio>=0.21.0",
-    "jupyter>=1.0.0",
-    "ipykernel>=6.0.0",
-    "nbstripout>=0.6.0",
-    "mypy>=1.0.0",
-    "ruff>=0.1.0",
-]
-
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools.package-dir]
-"flowquery" = "src"
-"flowquery.compute" = "src/compute"
-"flowquery.graph" = "src/graph"
-"flowquery.io" = "src/io"
-"flowquery.parsing" = "src/parsing"
-"flowquery.parsing.components" = "src/parsing/components"
-"flowquery.parsing.data_structures" = "src/parsing/data_structures"
-"flowquery.parsing.expressions" = "src/parsing/expressions"
-"flowquery.parsing.functions" = "src/parsing/functions"
-"flowquery.parsing.logic" = "src/parsing/logic"
-"flowquery.parsing.operations" = "src/parsing/operations"
-"flowquery.tokenization" = "src/tokenization"
-"flowquery.utils" = "src/utils"
-
-[tool.setuptools]
-packages = ["flowquery", "flowquery.compute", "flowquery.graph", "flowquery.io", "flowquery.parsing", "flowquery.parsing.components", "flowquery.parsing.data_structures", "flowquery.parsing.expressions", "flowquery.parsing.functions", "flowquery.parsing.logic", "flowquery.parsing.operations", "flowquery.tokenization", "flowquery.utils"]
-
-[tool.pytest.ini_options]
-minversion = "7.0"
-asyncio_mode = "auto"
-testpaths = ["tests"]
-python_files = ["test_*.py"]
-python_classes = ["Test*"]
-python_functions = ["test_*"]
-addopts = "-v --tb=short"
-
-[tool.pytest-asyncio]
-mode = "auto"
-
-[tool.mypy]
-python_version = "3.10"
-strict = true
-ignore_missing_imports = true
-exclude = [
-    "tests/",
-    "__pycache__",
-    ".git",
-    "build",
-    "dist",
-]
-
-[[tool.mypy.overrides]]
-module = "src.parsing.parser"
-warn_return_any = false
-disable_error_code = ["union-attr", "arg-type"]
-
-[tool.ruff]
-target-version = "py310"
-line-length = 120
-exclude = [
-    ".git",
-    "__pycache__",
-    "build",
-    "dist",
-]
-
-[tool.ruff.lint]
-select = [
-    "F",      # Pyflakes (includes F401 unused imports)
-    "E",      # pycodestyle errors
-    "W",      # pycodestyle warnings
-    "I",      # isort
-]
-ignore = [
-    "E501",   # line too long (handled by formatter)
-]
-
-[tool.ruff.lint.isort]
-known-first-party = ["flowquery", "src"]

package/flowquery-py/setup_env.ps1

@@ -1,92 +0,0 @@
-# FlowQuery Python Environment Setup Script for Windows (PowerShell)
-# This script creates a conda environment for FlowQuery development
-
-Write-Host "========================================"
-Write-Host "FlowQuery Python Environment Setup"
-Write-Host "========================================"
-Write-Host ""
-
-# Check if conda is available
-$condaPath = Get-Command conda -ErrorAction SilentlyContinue
-if (-not $condaPath) {
-    Write-Host "ERROR: Conda is not installed or not in PATH." -ForegroundColor Red
-    Write-Host "Please install Anaconda or Miniconda first."
-    exit 1
-}
-
-# Set environment name
-$envName = "flowquery"
-
-# Get Python version from pyproject.toml
-$pyprojectContent = Get-Content "pyproject.toml" -Raw
-if ($pyprojectContent -match 'requires-python\s*=\s*">=([0-9.]+)"') {
-    $pythonVersion = $matches[1]
-} else {
-    $pythonVersion = "3.10"  # fallback
-}
-Write-Host "Using Python version: $pythonVersion"
-
-# Check if environment already exists
-$envList = conda env list
-if ($envList -match "^$envName\s") {
-    Write-Host "Environment '$envName' already exists."
-    $recreate = Read-Host "Do you want to recreate it? (y/n)"
-    if ($recreate -eq "y" -or $recreate -eq "Y") {
-        Write-Host "Removing existing environment..."
-        conda env remove -n $envName -y
-    } else {
-        Write-Host "Keeping existing environment..."
-        Write-Host ""
-        Write-Host "========================================"
-        Write-Host "Environment ready!"
-        Write-Host "========================================"
-        Write-Host ""
-        Write-Host "To activate the environment, run:"
-        Write-Host "    conda activate $envName" -ForegroundColor Cyan
-        Write-Host ""
-        Write-Host "To run tests:"
-        Write-Host "    pytest tests/" -ForegroundColor Cyan
-        Write-Host ""
-        Write-Host "To deactivate when done:"
-        Write-Host "    conda deactivate" -ForegroundColor Cyan
-        exit 0
-    }
-}
-
-# Create the environment
-Write-Host ""
-Write-Host "Creating conda environment '$envName' with Python $pythonVersion..."
-conda create -n $envName python=$pythonVersion pip -y
-
-if ($LASTEXITCODE -ne 0) {
-    Write-Host ""
-    Write-Host "ERROR: Failed to create conda environment." -ForegroundColor Red
-    exit 1
-}
-
-# Activate and install package in dev mode
-Write-Host ""
-Write-Host "Installing package in development mode..."
-conda activate $envName
-pip install -e ".[dev]"
-
-if ($LASTEXITCODE -ne 0) {
-    Write-Host ""
-    Write-Host "ERROR: Failed to install package." -ForegroundColor Red
-    exit 1
-}
-
-Write-Host ""
-Write-Host "========================================"
-Write-Host "Environment created successfully!" -ForegroundColor Green
-Write-Host "========================================"
-Write-Host ""
-Write-Host "To activate the environment, run:"
-Write-Host "    conda activate $envName" -ForegroundColor Cyan
-Write-Host ""
-Write-Host "To run tests:"
-Write-Host "    pytest tests/" -ForegroundColor Cyan
-Write-Host ""
-Write-Host "To deactivate when done:"
-Write-Host "    conda deactivate" -ForegroundColor Cyan
-Write-Host ""