hydra-pg 0.15.0__tar.gz

hydra_pg-0.15.0/.gitignore

@@ -0,0 +1,99 @@
+# rattler-build output (build artifacts — deeply nested, causes Zed/git to thrash)
+output/
+
+# Release verification logs
+verify-logs/
+
+# Benchmarking runs
+benchmark/
+
+# Bootstrapping demo runs
+bootstrap/
+
+# Hydra wiki
+wiki/
+
+# Haskell / Stack / Cabal
+.ghcup/
+.stack-work
+dist-newstyle/
+stack.yaml.lock
+*.cabal
+
+# Java / Gradle
+.gradle
+gradle.properties
+build
+
+# IDEs
+.bsp/
+.idea
+*.iml
+.vscode
+
+# Python
+wheels/
+__pycache__/
+*.pyc
+.venv/
+.venv-*/
+.pytest_cache/
+.ruff_cache/
+
+# Node
+node_modules/
+
+# sbt build artifacts
+project/target/
+/target/
+# heads/scala has no build.sbt — these are orphan sbt scratch dirs
+heads/scala/target/
+heads/scala/project/
+
+# Run logs
+runs/
+
+# Analysis notebooks and debug scripts
+analysis/
+debug_*.py
+debug_*.hs
+debug_*.clj
+
+# Working documents (local only)
+docs/reviews/
+docs/work/
+
+# Package distributions.
+# dist/json/ is the source of truth (tracked). dist/haskell/ is tracked
+# through the 0.15 release to support bootstrapping from a fresh clone.
+# All other target-language trees are regenerated from dist/json/ and
+# not checked in.
+dist/clojure/
+dist/common-lisp/
+dist/coq/
+dist/emacs-lisp/
+dist/java/
+dist/python/
+dist/scala/
+dist/scheme/
+dist/wasm/
+
+# Test-cache artifacts written by Layer 2.5 testers. Per-target
+# digest.json files (dist/haskell/<pkg>/digest.json,
+# dist/json/<pkg>/digest.json) are tracked — they are the build's
+# source of truth for freshness checks.
+dist/haskell/test-cache.json
+
+# Per-package input-hash cache stamps written by assemble-distribution.sh
+# to short-circuit redundant work. Local caches, not part of the build.
+dist/haskell/*/.main-input-hash.txt
+dist/haskell/*/.test-input-hash.txt
+
+# Other
+*.log
+*.swp
+.claude
+# Hydra branch plan files (see CLAUDE.md)
+*-plan.md
+# Cross-worktree Claude messages (see CLAUDE.md)
+claude-hydra-messages/

hydra_pg-0.15.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: hydra-pg
+Version: 0.15.0
+Summary: Property graph support for Hydra: PG model, coders, GraphSON, Cypher, GQL, TinkerPop
+Project-URL: Homepage, https://github.com/CategoricalData/hydra
+Project-URL: Repository, https://github.com/CategoricalData/hydra
+Author-email: Joshua Shinavier <josh@fortytwo.net>
+License: Apache-2.0
+Requires-Python: >=3.12
+Requires-Dist: hydra-kernel==0.15.0
+Requires-Dist: hydra-rdf==0.15.0
+Description-Content-Type: text/markdown
+
+Property graph support for Hydra: PG model, coders, GraphSON, Cypher, GQL, TinkerPop

hydra_pg-0.15.0/pyproject.toml

@@ -0,0 +1,38 @@
+# Generated file. Do not edit.
+# Regenerated by bin/lib/generate-python-package-build.py from
+# packages/hydra-pg/package.json and the worktree's VERSION file. Each
+# dist/python/<pkg>/ is a standalone Python distribution: from this directory,
+# `uv build` (or `python -m build`) produces a wheel + sdist, and `pip install`
+# resolves transitive Hydra dependencies declared below.
+#
+# All Hydra wheels participate in the `hydra` namespace via PEP 420 implicit
+# namespace packages: there is no top-level hydra/__init__.py, so multiple
+# wheels can install side-by-side and merge their hydra.* contents at
+# import time. Subpackages (hydra/core/, hydra/rdf/syntax/, etc.) DO have
+# regular __init__.py files; only the namespace root is implicit.
+
+[project]
+name = "hydra-pg"
+version = "0.15.0"
+description = "Property graph support for Hydra: PG model, coders, GraphSON, Cypher, GQL, TinkerPop"
+readme = { text = "Property graph support for Hydra: PG model, coders, GraphSON, Cypher, GQL, TinkerPop", content-type = "text/markdown" }
+requires-python = ">=3.12"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "Joshua Shinavier", email = "josh@fortytwo.net" },
+]
+dependencies = [
+    "hydra-kernel == 0.15.0",
+    "hydra-rdf == 0.15.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/CategoricalData/hydra"
+Repository = "https://github.com/CategoricalData/hydra"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/main/python/hydra"]

hydra_pg-0.15.0/src/main/digest.json

@@ -0,0 +1,64 @@
+{
+  "version": 2,
+  "generator": "v0-unstamped",
+  "inputs": {
+    "com.gdblab.pathAlgebra.expressions": { "kind": "Other", "hash": "cc19fd8b0065ea6ffdf431101ed9040a0bb72e193c110f6e6ea7d5019ced66ef" },
+    "com.gdblab.pathAlgebra.syntax": { "kind": "Other", "hash": "d6ff685be0717cf9b68ed596d78b174a46f3d521c44830765df529024a7bdde9" },
+    "hydra.cypher.features": { "kind": "Other", "hash": "a7b8b29fe598a31fd754d93f0250ff85c66cf22888e18256643ec02ac7909853" },
+    "hydra.cypher.openCypher": { "kind": "Other", "hash": "b496391f47349e251c44ded811ba59cc2272caff66d175161989a5532d45abc2" },
+    "hydra.error.pg": { "kind": "Other", "hash": "67688aec530985d296b79d254a99eeac36e129b54db94428292d2cae5f28582a" },
+    "hydra.graphviz.coder": { "kind": "Other", "hash": "b6bb0046c9bf5ac72cca47fad1e8205b66b9036d01b0fbab92b44f2726f3147e" },
+    "hydra.graphviz.dot": { "kind": "Other", "hash": "c9f1684114d6cc17f990d70ae2bccddd7ff651c29c67777cb132127762cb66d0" },
+    "hydra.graphviz.serde": { "kind": "Other", "hash": "a0ab37a15451c82489e2748212e61b3a1e41793e3a48248b60f13910db6e6f8c" },
+    "hydra.pg.coder": { "kind": "Other", "hash": "0cde6b51326610c12ccfab0277dc93541c22ebd9bb55616b147743a429300772" },
+    "hydra.pg.graphson.coder": { "kind": "Other", "hash": "61c6fae74af1561f56861075035fb38df08608fc1ab1460f9139946c3c219b33" },
+    "hydra.pg.graphson.construct": { "kind": "Other", "hash": "986aa90dcc1077393e3768f589692c5b002759c6b90eb25f3abe72e1e606e582" },
+    "hydra.pg.graphson.syntax": { "kind": "Other", "hash": "49848c6ea52f0965118736513db8af626428cce19aa3bf07518c1b83fdc0a23f" },
+    "hydra.pg.graphson.utils": { "kind": "Other", "hash": "942c5274460dd3692b98dae69f65e405ca2f76b5436dfa3a171888a2c6d336e0" },
+    "hydra.pg.mapping": { "kind": "Other", "hash": "0d76cd4528c761a05ec1e7a7e81b8459a2f98c52e73ff1135acdace94982623a" },
+    "hydra.pg.model": { "kind": "Other", "hash": "cd64d2b3693a514801028e38990f7f1f0750963ef9d1df4a45b0fbab42f8650b" },
+    "hydra.pg.printing": { "kind": "Other", "hash": "d032bf3ebd2ad88631c4b6b22dbbef7a6c01afd4c9ac12a4a0cd726be87e7bb6" },
+    "hydra.pg.query": { "kind": "Other", "hash": "d4dce2ec663c80f254bcc6bee6e33459c42b2b0299130bf7bb659becd473fdca" },
+    "hydra.pg.rdf.environment": { "kind": "Other", "hash": "d144365177eb66a667fdcc37d12f3e06316566123086f9415ffba836bc6c94ec" },
+    "hydra.pg.rdf.mappings": { "kind": "Other", "hash": "b47327d0d679f53d2d4b75f515e992750b17372372559517706c5bb56d582c19" },
+    "hydra.pg.termsToElements": { "kind": "Other", "hash": "ff37b4144fad84fe4c80b4c86844b13ace79ab473be116f98f78fee43b6ba351" },
+    "hydra.pg.utils": { "kind": "Other", "hash": "549e78a85871a70416b1e5deba02b8395f906bf33c32b59ed0f00595bd63f2bb" },
+    "hydra.tinkerpop.features": { "kind": "Other", "hash": "5d746e32d4768f6a21564a261c41145207e3fd53b732537c7c40af1cdddd30a3" },
+    "hydra.tinkerpop.gremlin": { "kind": "Other", "hash": "8c58b7f204b532d1d3334ad85aad7f1ef4ee13c9b3f18574098c03df5ca06373" },
+    "hydra.tinkerpop.language": { "kind": "Other", "hash": "1752ad9c0977168d01c835c25819aa7b74aa57cbdd080096142f1cad2abe1900" },
+    "openGql.grammar": { "kind": "Other", "hash": "35c3b344abe933126eb25e9e0675828b780c6f795587128f13dbfb65e743eb26" }
+  },
+  "outputs": {
+    "com/gdblab/path_algebra/expressions.py": { "kind": "TargetFile", "hash": "99aa924006dd729021e8abfc932d89fbd12979aa68bc94c531368377db44c559" },
+    "com/gdblab/path_algebra/syntax.py": { "kind": "TargetFile", "hash": "743209c73644a316a42ca0708cb1a780bc866ee51915432f2c2e9487a3d6f3af" },
+    "hydra/cypher/features.py": { "kind": "TargetFile", "hash": "d6f53ca8d49f8784ad3fb9166928876e5589685adb2d9e8e02d823b87e546d24" },
+    "hydra/cypher/open_cypher.py": { "kind": "TargetFile", "hash": "6ee7cd2223074483dfea768bb1b573c6a740f9d52f5417b8a01d2f6af11218f0" },
+    "hydra/decode/pg/mapping.py": { "kind": "TargetFile", "hash": "741b5c15baa8f0f7feb42ce946d0f1c30084df941ef3a54b08efc0c58098fee6" },
+    "hydra/decode/pg/model.py": { "kind": "TargetFile", "hash": "9bc1e4a819a3a77d429a52c27868ee956100599d290d8d8844c0f6f3371258fb" },
+    "hydra/demos/genpg/transform.py": { "kind": "TargetFile", "hash": "cdc19f58efd60a4c38ac3e2a41161ad881f52b1008aa99681e29aab3d34752e5" },
+    "hydra/encode/pg/mapping.py": { "kind": "TargetFile", "hash": "da59748c52233df908a6bc08403de9ee8d9da94c6e27c21d32ee3bba36762c39" },
+    "hydra/encode/pg/model.py": { "kind": "TargetFile", "hash": "943998797ec60e2bd62a73e8add21bcf0b0f4cfa39390810d7a6687f2d3069a1" },
+    "hydra/error/pg.py": { "kind": "TargetFile", "hash": "ed355f6226d2b7faed672a0c77e6517a2ca3aee479de1f572b826736dbd03081" },
+    "hydra/graphviz/coder.py": { "kind": "TargetFile", "hash": "50d1a68b0cfabb35a2604350f67cf57aa119beee390ca202974362d1b400c532" },
+    "hydra/graphviz/dot.py": { "kind": "TargetFile", "hash": "4f0ba63ead99ab6d777acf46457eaf825eacf05f4e889ac2af1b271ede857191" },
+    "hydra/graphviz/serde.py": { "kind": "TargetFile", "hash": "7a9c8a601c40a70c714193a738d46f12b8a61c76448d96fb14ba234ddf3196a4" },
+    "hydra/pg/coder.py": { "kind": "TargetFile", "hash": "e9689becbee0d84061c49315a3802b525ee6eca6e4cf6d3e932d6ae9c021736e" },
+    "hydra/pg/graphson/coder.py": { "kind": "TargetFile", "hash": "c3371fa6a12a87f5bf47e248a8027dea013964b6832cfa88ae6732a5ffa7ed9f" },
+    "hydra/pg/graphson/construct.py": { "kind": "TargetFile", "hash": "be01def4296e030d2d274d358c1b2b6dd71e2e69f5c5acb0beb6406b1dd23543" },
+    "hydra/pg/graphson/syntax.py": { "kind": "TargetFile", "hash": "6359833f2aecdafb44803c09565bc5f4d29e5d94159c5ce3d1d0a1d1fe90e893" },
+    "hydra/pg/graphson/utils.py": { "kind": "TargetFile", "hash": "6e4b7a0bc1f498ed775d171535ae761cd1c63ef1d082e04eecc8440ae71e9fb6" },
+    "hydra/pg/mapping.py": { "kind": "TargetFile", "hash": "9e534669eb69fa2a610ef0111c9291186416b269d2b01d47d5b64ceb8dc8020b" },
+    "hydra/pg/model.py": { "kind": "TargetFile", "hash": "4b271334e0040f346625a2fceaea6c2511976adfd6efcbb337d056e6de08b7c5" },
+    "hydra/pg/printing.py": { "kind": "TargetFile", "hash": "40e1a5582a70cdecd4abefee92955a7866b9b37f46531d7f2da4cac36db556e3" },
+    "hydra/pg/query.py": { "kind": "TargetFile", "hash": "627bbb1cb77974959b22893698130a79997f5edc12152462b5c932e2bdc3b3ca" },
+    "hydra/pg/rdf/environment.py": { "kind": "TargetFile", "hash": "f4f65c0b9f15da1b8093245ecb5b0501d6e019a13e9065828cd3d8187c3df42c" },
+    "hydra/pg/rdf/mappings.py": { "kind": "TargetFile", "hash": "505c44e6d396e367f1d5b3d5b8d6bc8286fa8b72d3879b04a5cc55a803a6a84a" },
+    "hydra/pg/terms_to_elements.py": { "kind": "TargetFile", "hash": "1655965973d82c6fee099b8eac343dcf1fa0caa6d009bb6dddd4683f768fa45b" },
+    "hydra/pg/utils.py": { "kind": "TargetFile", "hash": "436deb139fdf926edec6b7088145c224ef9ef56c1bfc6431e512ce17616b42b6" },
+    "hydra/tinkerpop/features.py": { "kind": "TargetFile", "hash": "aebb1a0d09b3c01c7bd7ea9c5be0aa7f04ad81596477f139f95a56f7ab4f6451" },
+    "hydra/tinkerpop/gremlin.py": { "kind": "TargetFile", "hash": "3811add12df8acee9f5e0506ecf4eb1fbd89b623f5b8fed9f7e06f4215a26628" },
+    "hydra/tinkerpop/language.py": { "kind": "TargetFile", "hash": "b8186a4582761933189583b9b59e18783816874eec99e1cf2f64f09244149998" },
+    "hydra/validate/pg.py": { "kind": "TargetFile", "hash": "9383e2edbece72706242da5ee799f48ee00517b759845b6f5f3c1207ad683744" },
+    "open_gql/grammar.py": { "kind": "TargetFile", "hash": "e98b7f3351c82198bf1f0d2e41327264661362dee9f04276925b3a00628ef7fc" }
+  }
+}

hydra_pg-0.15.0/src/main/python/com/gdblab/path_algebra/expressions.py

@@ -0,0 +1,386 @@
+# Note: this is an automatically generated file. Do not edit.
+r"""Algebraic expression trees for the path algebra by Angles et al., extended for GQL support."""
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+from functools import lru_cache
+from hydra.dsl.python import Maybe, Node, frozenlist
+from typing import TypeAlias, cast
+import hydra.core
+@dataclass(frozen=True)
+class QueryExpression:
+    r"""Complete query with path algebra and result projection."""
+    path_expression: PathExpression
+    result_projection: Maybe[ResultProjection]
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.QueryExpression")
+    PATH_EXPRESSION = hydra.core.Name("pathExpression")
+    RESULT_PROJECTION = hydra.core.Name("resultProjection")
+class PathExpressionBase(Node["BaseExpression"]):
+    r"""Base case: extract paths from graph"""
+class PathExpressionSelection(Node["SelectionExpression"]):
+    r"""Selection operator (σ): filter paths by condition"""
+class PathExpressionJoin(Node["JoinExpression"]):
+    r"""Join operator (⊲⊳): concatenate compatible paths"""
+class PathExpressionUnion(Node["UnionExpression"]):
+    r"""Union operator (∪): combine path sets"""
+class PathExpressionRecursive(Node["RecursiveExpression"]):
+    r"""Recursive operator (φ): compute transitive closure with semantics"""
+class PathExpressionGroupBy(Node["GroupByExpression"]):
+    r"""Group-by operator (γ): organize paths into solution space"""
+class PathExpressionOrderBy(Node["OrderByExpression"]):
+    r"""Order-by operator (τ): sort solution space"""
+class PathExpressionProjection(Node["ProjectionExpression"]):
+    r"""Projection operator (π): extract paths from solution space"""
+class _PathExpressionMeta(type):
+    def __getitem__(cls, item):
+        return object
+# A path algebra expression that evaluates to a set of paths.
+class PathExpression(metaclass=_PathExpressionMeta):
+    r"""PathExpressionBase | PathExpressionSelection | PathExpressionJoin | PathExpressionUnion | PathExpressionRecursive | PathExpressionGroupBy | PathExpressionOrderBy | PathExpressionProjection"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PathExpression")
+    BASE = hydra.core.Name("base")
+    SELECTION = hydra.core.Name("selection")
+    JOIN = hydra.core.Name("join")
+    UNION = hydra.core.Name("union")
+    RECURSIVE = hydra.core.Name("recursive")
+    GROUP_BY = hydra.core.Name("groupBy")
+    ORDER_BY = hydra.core.Name("orderBy")
+    PROJECTION = hydra.core.Name("projection")
+class BaseExpressionPaths0(Node["GraphReference"]):
+    r"""Paths0(G): all paths of length 0 (nodes)"""
+class BaseExpressionPaths1(Node["GraphReference"]):
+    r"""Paths1(G): all paths of length 1 (edges)"""
+class BaseExpressionPathsStar(Node["GraphReference"]):
+    r"""Paths*(G): all paths in graph (infinite without restrictions)"""
+class _BaseExpressionMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Base path expressions that extract paths from graph.
+class BaseExpression(metaclass=_BaseExpressionMeta):
+    r"""BaseExpressionPaths0 | BaseExpressionPaths1 | BaseExpressionPathsStar"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.BaseExpression")
+    PATHS0 = hydra.core.Name("paths0")
+    PATHS1 = hydra.core.Name("paths1")
+    PATHS_STAR = hydra.core.Name("pathsStar")
+class GraphReference(Node[str]):
+    r"""Reference to a property graph."""
+GraphReference.TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.GraphReference")
+@dataclass(frozen=True)
+class SelectionExpression:
+    r"""Selection operator: σ_condition(expression)."""
+    condition: SelectionCondition
+    expression: PathExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.SelectionExpression")
+    CONDITION = hydra.core.Name("condition")
+    EXPRESSION = hydra.core.Name("expression")
+class SelectionConditionSimple(Node["SimpleCondition"]):
+    ...
+class SelectionConditionAnd(Node["AndCondition"]):
+    ...
+class SelectionConditionOr(Node["OrCondition"]):
+    ...
+class SelectionConditionNot(Node["NotCondition"]):
+    ...
+class _SelectionConditionMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Conditions for filtering paths.
+class SelectionCondition(metaclass=_SelectionConditionMeta):
+    r"""SelectionConditionSimple | SelectionConditionAnd | SelectionConditionOr | SelectionConditionNot"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.SelectionCondition")
+    SIMPLE = hydra.core.Name("simple")
+    AND = hydra.core.Name("and")
+    OR = hydra.core.Name("or")
+    NOT = hydra.core.Name("not")
+class SimpleConditionLabelEquals(Node["LabelCondition"]):
+    ...
+class SimpleConditionPropertyEquals(Node["PropertyCondition"]):
+    ...
+class SimpleConditionPropertyComparison(Node["PropertyComparisonCondition"]):
+    ...
+class SimpleConditionLengthEquals(Node["LengthCondition"]):
+    ...
+class _SimpleConditionMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Atomic selection conditions.
+class SimpleCondition(metaclass=_SimpleConditionMeta):
+    r"""SimpleConditionLabelEquals | SimpleConditionPropertyEquals | SimpleConditionPropertyComparison | SimpleConditionLengthEquals"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.SimpleCondition")
+    LABEL_EQUALS = hydra.core.Name("labelEquals")
+    PROPERTY_EQUALS = hydra.core.Name("propertyEquals")
+    PROPERTY_COMPARISON = hydra.core.Name("propertyComparison")
+    LENGTH_EQUALS = hydra.core.Name("lengthEquals")
+@dataclass(frozen=True)
+class LabelCondition:
+    r"""Conditions on node/edge labels: label(node(i)) = v."""
+    target: PathElement
+    value: str
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.LabelCondition")
+    TARGET = hydra.core.Name("target")
+    VALUE = hydra.core.Name("value")
+@dataclass(frozen=True)
+class PropertyCondition:
+    r"""Property equality conditions: node(i).prop = v."""
+    target: PathElement
+    property: str
+    value: LiteralValue
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PropertyCondition")
+    TARGET = hydra.core.Name("target")
+    PROPERTY = hydra.core.Name("property")
+    VALUE = hydra.core.Name("value")
+@dataclass(frozen=True)
+class PropertyComparisonCondition:
+    r"""Property comparison conditions: node(i).prop > v, etc."""
+    target: PathElement
+    property: str
+    operator: ComparisonOperator
+    value: LiteralValue
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PropertyComparisonCondition")
+    TARGET = hydra.core.Name("target")
+    PROPERTY = hydra.core.Name("property")
+    OPERATOR = hydra.core.Name("operator")
+    VALUE = hydra.core.Name("value")
+class ComparisonOperator(Enum):
+    r"""Comparison operators for property conditions."""
+    EQUAL = hydra.core.Name("equal")
+    NOT_EQUAL = hydra.core.Name("notEqual")
+    LESS_THAN = hydra.core.Name("lessThan")
+    LESS_THAN_OR_EQUAL = hydra.core.Name("lessThanOrEqual")
+    GREATER_THAN = hydra.core.Name("greaterThan")
+    GREATER_THAN_OR_EQUAL = hydra.core.Name("greaterThanOrEqual")
+ComparisonOperator.TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.ComparisonOperator")
+class LiteralValueString(Node[str]):
+    ...
+class LiteralValueInteger(Node[int]):
+    ...
+class LiteralValueFloat(Node[float]):
+    ...
+class LiteralValueBoolean(Node[bool]):
+    ...
+class _LiteralValueMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Literal values for comparisons.
+class LiteralValue(metaclass=_LiteralValueMeta):
+    r"""LiteralValueString | LiteralValueInteger | LiteralValueFloat | LiteralValueBoolean"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.LiteralValue")
+    STRING = hydra.core.Name("string")
+    INTEGER = hydra.core.Name("integer")
+    FLOAT = hydra.core.Name("float")
+    BOOLEAN = hydra.core.Name("boolean")
+@dataclass(frozen=True)
+class LengthCondition:
+    r"""Condition on path length: len() = i."""
+    length: int
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.LengthCondition")
+    LENGTH = hydra.core.Name("length")
+class PathElementNode(Node[int]):
+    ...
+class PathElementEdge(Node[int]):
+    ...
+class PathElementFirst:
+    __slots__ = ()
+    def __eq__(self, other):
+        return isinstance(other, PathElementFirst)
+    def __hash__(self):
+        return hash("PathElementFirst")
+class PathElementLast:
+    __slots__ = ()
+    def __eq__(self, other):
+        return isinstance(other, PathElementLast)
+    def __hash__(self):
+        return hash("PathElementLast")
+class _PathElementMeta(type):
+    def __getitem__(cls, item):
+        return object
+# References to elements within a path.
+class PathElement(metaclass=_PathElementMeta):
+    r"""PathElementNode | PathElementEdge | PathElementFirst | PathElementLast"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PathElement")
+    NODE = hydra.core.Name("node")
+    EDGE = hydra.core.Name("edge")
+    FIRST = hydra.core.Name("first")
+    LAST = hydra.core.Name("last")
+@dataclass(frozen=True)
+class AndCondition:
+    left: SelectionCondition
+    right: SelectionCondition
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.AndCondition")
+    LEFT = hydra.core.Name("left")
+    RIGHT = hydra.core.Name("right")
+@dataclass(frozen=True)
+class OrCondition:
+    left: SelectionCondition
+    right: SelectionCondition
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.OrCondition")
+    LEFT = hydra.core.Name("left")
+    RIGHT = hydra.core.Name("right")
+@dataclass(frozen=True)
+class NotCondition:
+    condition: SelectionCondition
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.NotCondition")
+    CONDITION = hydra.core.Name("condition")
+@dataclass(frozen=True)
+class JoinExpression:
+    r"""Join operator: expr1 ⊲⊳ expr2."""
+    left: PathExpression
+    right: PathExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.JoinExpression")
+    LEFT = hydra.core.Name("left")
+    RIGHT = hydra.core.Name("right")
+@dataclass(frozen=True)
+class UnionExpression:
+    r"""Union operator: expr1 ∪ expr2."""
+    left: PathExpression
+    right: PathExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.UnionExpression")
+    LEFT = hydra.core.Name("left")
+    RIGHT = hydra.core.Name("right")
+@dataclass(frozen=True)
+class RecursiveExpression:
+    r"""Recursive operator with path semantics."""
+    semantics: PathSemantics
+    expression: PathExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.RecursiveExpression")
+    SEMANTICS = hydra.core.Name("semantics")
+    EXPRESSION = hydra.core.Name("expression")
+class PathSemantics(Enum):
+    r"""Path semantics for recursive operations."""
+    WALK = hydra.core.Name("walk")
+    TRAIL = hydra.core.Name("trail")
+    ACYCLIC = hydra.core.Name("acyclic")
+    SIMPLE = hydra.core.Name("simple")
+    SHORTEST = hydra.core.Name("shortest")
+PathSemantics.TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PathSemantics")
+class SolutionSpaceExpressionGroupBy(Node["GroupByExpression"]):
+    ...
+class SolutionSpaceExpressionOrderBy(Node["OrderByExpression"]):
+    ...
+class _SolutionSpaceExpressionMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Expressions that work with solution spaces.
+class SolutionSpaceExpression(metaclass=_SolutionSpaceExpressionMeta):
+    r"""SolutionSpaceExpressionGroupBy | SolutionSpaceExpressionOrderBy"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.SolutionSpaceExpression")
+    GROUP_BY = hydra.core.Name("groupBy")
+    ORDER_BY = hydra.core.Name("orderBy")
+@dataclass(frozen=True)
+class GroupByExpression:
+    r"""Group-by operator: γ_criterion(expression)."""
+    criterion: GroupByCriterion
+    expression: PathExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.GroupByExpression")
+    CRITERION = hydra.core.Name("criterion")
+    EXPRESSION = hydra.core.Name("expression")
+class GroupByCriterion(Enum):
+    r"""Grouping criteria corresponding to paper's γ variants."""
+    NONE = hydra.core.Name("none")
+    SOURCE = hydra.core.Name("source")
+    TARGET = hydra.core.Name("target")
+    LENGTH = hydra.core.Name("length")
+    SOURCE_TARGET = hydra.core.Name("sourceTarget")
+    SOURCE_LENGTH = hydra.core.Name("sourceLength")
+    TARGET_LENGTH = hydra.core.Name("targetLength")
+    SOURCE_TARGET_LENGTH = hydra.core.Name("sourceTargetLength")
+GroupByCriterion.TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.GroupByCriterion")
+@dataclass(frozen=True)
+class OrderByExpression:
+    r"""Order-by operator: τ_criterion(solutionSpace)."""
+    criterion: OrderByCriterion
+    expression: SolutionSpaceExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.OrderByExpression")
+    CRITERION = hydra.core.Name("criterion")
+    EXPRESSION = hydra.core.Name("expression")
+class OrderByCriterion(Enum):
+    r"""Ordering criteria corresponding to paper's τ variants."""
+    PARTITION = hydra.core.Name("partition")
+    GROUP = hydra.core.Name("group")
+    PATH = hydra.core.Name("path")
+    PARTITION_GROUP = hydra.core.Name("partitionGroup")
+    PARTITION_PATH = hydra.core.Name("partitionPath")
+    GROUP_PATH = hydra.core.Name("groupPath")
+    PARTITION_GROUP_PATH = hydra.core.Name("partitionGroupPath")
+OrderByCriterion.TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.OrderByCriterion")
+@dataclass(frozen=True)
+class ProjectionExpression:
+    r"""Projection operator: π_(#P,#G,#A)(solutionSpace)."""
+    partitions: ProjectionSpec
+    groups: ProjectionSpec
+    paths: ProjectionSpec
+    expression: SolutionSpaceExpression
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.ProjectionExpression")
+    PARTITIONS = hydra.core.Name("partitions")
+    GROUPS = hydra.core.Name("groups")
+    PATHS = hydra.core.Name("paths")
+    EXPRESSION = hydra.core.Name("expression")
+class ProjectionSpecAll:
+    __slots__ = ()
+    def __eq__(self, other):
+        return isinstance(other, ProjectionSpecAll)
+    def __hash__(self):
+        return hash("ProjectionSpecAll")
+class ProjectionSpecLimited(Node[int]):
+    ...
+class _ProjectionSpecMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Projection specification: * or specific number.
+class ProjectionSpec(metaclass=_ProjectionSpecMeta):
+    r"""ProjectionSpecAll | ProjectionSpecLimited"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.ProjectionSpec")
+    ALL = hydra.core.Name("all")
+    LIMITED = hydra.core.Name("limited")
+@dataclass(frozen=True)
+class ResultProjection:
+    r"""Extract specific values from paths for RETURN clause."""
+    projections: frozenlist[PropertyExtraction]
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.ResultProjection")
+    PROJECTIONS = hydra.core.Name("projections")
+@dataclass(frozen=True)
+class PropertyExtraction:
+    r"""Extract properties from path elements."""
+    alias: Maybe[str]
+    source: PropertySource
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PropertyExtraction")
+    ALIAS = hydra.core.Name("alias")
+    SOURCE = hydra.core.Name("source")
+class PropertySourceNodeProperty(Node["NodePropertyRef"]):
+    ...
+class PropertySourceEdgeProperty(Node["EdgePropertyRef"]):
+    ...
+class PropertySourcePathProperty(Node["PathPropertyRef"]):
+    ...
+class _PropertySourceMeta(type):
+    def __getitem__(cls, item):
+        return object
+# Source of a property value.
+class PropertySource(metaclass=_PropertySourceMeta):
+    r"""PropertySourceNodeProperty | PropertySourceEdgeProperty | PropertySourcePathProperty"""
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PropertySource")
+    NODE_PROPERTY = hydra.core.Name("nodeProperty")
+    EDGE_PROPERTY = hydra.core.Name("edgeProperty")
+    PATH_PROPERTY = hydra.core.Name("pathProperty")
+@dataclass(frozen=True)
+class NodePropertyRef:
+    r"""Reference to a node property: node.property."""
+    element: PathElement
+    property: str
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.NodePropertyRef")
+    ELEMENT = hydra.core.Name("element")
+    PROPERTY = hydra.core.Name("property")
+@dataclass(frozen=True)
+class EdgePropertyRef:
+    r"""Reference to an edge property: edge.property."""
+    element: PathElement
+    property: str
+    TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.EdgePropertyRef")
+    ELEMENT = hydra.core.Name("element")
+    PROPERTY = hydra.core.Name("property")
+class PathPropertyRef(Enum):
+    r"""Reference to path-level properties: length, etc."""
+    LENGTH = hydra.core.Name("length")
+    START_NODE = hydra.core.Name("startNode")
+    END_NODE = hydra.core.Name("endNode")
+PathPropertyRef.TYPE_ = hydra.core.Name("com.gdblab.pathAlgebra.expressions.PathPropertyRef")