PyLegend 2.0

.github/workflows/actions/mypy_type_check/action.yml

@@ -30,17 +30,8 @@ runs:
     - name: MyPy Type Check
       shell: bash
       run: |
-        if [ "$RUNNER_OS" == "Windows" ]; then
-          source .venv/Scripts/activate
-        else
-          source .venv/bin/activate
-        fi
-        echo "Installing mypy"
-        pip install mypy
-        echo "Done with installing mypy"
-        echo "MyPy executable is:" $(which mypy)
         echo "Running mypy ./.github/workflows/ --config-file=./.github/workflows/typing/config.cfg"
-        mypy ./.github/workflows/ --config-file=./.github/workflows/typing/config.cfg 
+        uv run --with mypy mypy ./.github/workflows/ --config-file=./.github/workflows/typing/config.cfg
         echo "Running mypy ./pylegend/ ./tests/ --config-file=./.github/workflows/typing/config.cfg"
-        mypy ./pylegend/ ./tests/ --config-file=./.github/workflows/typing/config.cfg
+        uv run --with mypy mypy ./pylegend/ ./tests/ --config-file=./.github/workflows/typing/config.cfg
         echo "Done with typing check"

.github/workflows/actions/poetry_build/action.yml

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-name: Poetry Build
+name: Build
 
-description: Poetry Build
+description: Build
 
 runs:
   using: "composite"
@@ -24,30 +24,19 @@ runs:
       with:
         python-version: 3.12
 
-    - name: Poetry Install Dependencies
+    - name: Install Dependencies
       uses: ./.github/workflows/actions/poetry_install_dependencies
 
-    - name: Poetry Version Bump
+    - name: Version Bump
       shell: bash
       run: |
-        if [ "$RUNNER_OS" == "Windows" ]; then
-          source .venv/Scripts/activate
-        else
-          source .venv/bin/activate
-        fi
-        echo "Poetry executable is:" $(which poetry)
-        poetry version $(poetry version --short).dev$GITHUB_RUN_NUMBER
-        echo "Updated version is:" $(poetry version --short)
+        current_version=$(python -c "import tomllib; data = tomllib.load(open('pyproject.toml', 'rb')); print(data['project']['version'])")
+        uv version "${current_version}.dev${GITHUB_RUN_NUMBER}"
+        echo "Updated version is:" $(python -c "import tomllib; data = tomllib.load(open('pyproject.toml', 'rb')); print(data['project']['version'])")
 
-    - name: Poetry Build
+    - name: Build
       shell: bash
       run: |
-        if [ "$RUNNER_OS" == "Windows" ]; then
-          source .venv/Scripts/activate
-        else
-          source .venv/bin/activate
-        fi
-        echo "Poetry executable is:" $(which poetry)
-        echo "Running poetry build"
-        poetry build
-        echo "Done with poetry build"
+        echo "Running uv build"
+        uv build
+        echo "Done with build"

.github/workflows/actions/poetry_install_dependencies/action.yml

@@ -12,22 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-name: Poetry Install Dependencies
+name: Install Dependencies
 
-description: Poetry Install Dependencies
+description: Install Dependencies
 
 runs:
   using: "composite"
   steps:
-    - name: Poetry Install Dependencies
+    - name: Install Dependencies
       shell: bash
       run: |
-        if [ "$RUNNER_OS" == "Windows" ]; then
-          source .venv/Scripts/activate
-        else
-          source .venv/bin/activate
-        fi
-        echo "Poetry executable is:" $(which poetry)
-        echo "Running poetry install"
-        poetry install --with dev
+        echo "Running uv sync"
+        uv sync
         echo "Done with installing dependencies"

.github/workflows/actions/setup/action.yml

@@ -29,25 +29,16 @@ runs:
       with:
         python-version: ${{ inputs.python-version }}
 
-    - name: Install Poetry
+    - name: Install uv
       run: |
-        echo "Install poetry"
-        pip install poetry
+        echo "Install uv"
+        pip install uv
       shell: bash
 
     - name: Setup Virtual Environment
       run: |
         echo "Python version is:" $(python --version)
-        echo "Creating and activating virtual environment"
-        python -m venv .venv
-        if [ "$RUNNER_OS" == "Windows" ]; then
-          source .venv/Scripts/activate
-        else
-          source .venv/bin/activate
-        fi
-        echo "Done with activating virtual environment"
-        echo "Python executable is:" $(which python)
-        echo "Update pip and setuptools"
-        python -m pip install --upgrade pip setuptools
+        echo "Creating virtual environment"
+        uv venv .venv
         echo "Setup complete"
       shell: bash

.github/workflows/cve-scanning.yml

@@ -46,6 +46,6 @@ jobs:
       - name: Scan CVEs
         run: |
           source .venv/bin/activate
-          poetry install --with dev
+          uv sync
           which safety
           safety check --full-report

.github/workflows/license-scanning.yml

@@ -46,5 +46,5 @@ jobs:
       - name: Scan Licenses
         run: |
           source .venv/bin/activate
-          poetry install --with dev
-          pip-licenses --format=markdown --order=license --allow-only="MIT License;Apache Software License;BSD License;Mozilla Public License 2.0 (MPL 2.0);MIT No Attribution License (MIT-0);Python Software Foundation License;Apache-2.0;BSD-2-Clause;BSD-3-Clause;BSD-3-Clause AND ISC;MIT;PSF-2.0;Apache-2.0 OR BSD-3-Clause;MIT AND Python-2.0;Apache-2.0 OR BSD-2-Clause;BSD-3-Clause AND 0BSD AND MIT AND Zlib AND CC0-1.0;MIT AND PSF-2.0;"
+          uv sync
+          pip-licenses --format=markdown --order=license --allow-only="MIT License;Apache Software License;BSD License;Mozilla Public License 2.0 (MPL 2.0);MIT No Attribution License (MIT-0);Python Software Foundation License;Apache-2.0;BSD-2-Clause;BSD-3-Clause;BSD-3-Clause AND ISC;MIT;PSF-2.0;Apache-2.0 OR BSD-3-Clause;MIT AND Python-2.0;Apache-2.0 OR BSD-2-Clause;BSD-3-Clause AND 0BSD AND MIT AND Zlib AND CC0-1.0;MIT AND PSF-2.0;MIT OR Apache-2.0;"

.github/workflows/release.yml

@@ -37,13 +37,7 @@ jobs:
         id: validate_and_set_image_tag
         shell: bash
         run: |
-          if [ "$RUNNER_OS" == "Windows" ]; then
-            source .venv/Scripts/activate
-          else
-            source .venv/bin/activate
-          fi
-          echo "Poetry executable is:" $(which poetry)
-          project_version=$(poetry version --short)
+          project_version=$(python -c "import tomllib; data = tomllib.load(open('pyproject.toml', 'rb')); print(data['project']['version'])")
           release_version=${GITHUB_REF#refs/*/pylegend-}
           if [ ${project_version} == ${release_version} ]; then
             echo "Version matches"
@@ -111,13 +105,9 @@ jobs:
           PYPI_USERNAME: ${{ secrets.PYPI_USERNAME }}
           PYPI_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
         run: |
-          if [ "$RUNNER_OS" == "Windows" ]; then
-            source .venv/Scripts/activate
-          else
-            source .venv/bin/activate
-          fi
-          echo "Poetry executable is:" $(which poetry)
-          poetry publish --build --username "$PYPI_USERNAME" --password "$PYPI_PASSWORD"
+          echo "Building and publishing to PyPI"
+          uv build
+          uv publish --username "$PYPI_USERNAME" --password "$PYPI_PASSWORD"
 
   docker_build_push:
     name: Build-Push Docker Image

.planning/PROJECT.md

@@ -0,0 +1,85 @@
+# PyLegend 2.0
+
+## What This Is
+
+PyLegend is a Python client library for the [FINOS Legend](https://legend.finos.org/) platform that enables users to build tabular dataset queries using a Python API, compile them to Pure (the Legend functional query language), and execute them against a Legend engine. Version 2.0 replaces the multi-API architecture with a single Ibis backend (`ibis.legend`), while preserving the LegendQL API as a backwards-compatible wrapper for existing users.
+
+## Core Value
+
+Internal library teams and Legend PCT tests can build and execute TDS queries against a Legend engine using familiar Python APIs without maintaining knowledge of the underlying Pure or engine protocol.
+
+## Requirements
+
+### Validated
+
+- ✓ LegendQL API (`LegendQLApiTdsClient`) with TdsFrame operations (filter, restrict, extend, rename, groupBy, aggregate, join, and all current dataframe operations) — existing
+- ✓ Pure expression generation via `to_pure_expression()` — existing
+- ✓ Legend service and function frame inputs — existing
+- ✓ HTTP client with auth schemes (`HeaderTokenAuthScheme`) — existing
+- ✓ Streaming result handlers (CSV, Pandas DataFrame, string) — existing
+- ✓ CI matrix across Python 3.9–3.14 on Ubuntu and Windows — existing
+
+### Active
+
+- [ ] Ibis backend registered and importable as `ibis.legend`
+- [ ] Ibis backend compiles Ibis table expressions to Pure strings
+- [ ] Ibis backend connects to Legend services (for organizations with internal instances)
+- [ ] All TdsFrame operations currently in the LegendQL API continue to work via the Ibis backend
+- [ ] LegendQL API reimplemented as a thin wrapper over the Ibis backend
+- [ ] Legacy API removed
+- [ ] Pandas API removed
+- [ ] SQL compilation layer removed (not needed; Pure generation is the target output)
+- [ ] Legend PCT matrix remains green after rewrite
+
+### Out of Scope
+
+- SQL generation — Pure generation is the only compilation target in 2.0
+- Legacy API maintenance — being removed in this milestone
+- Pandas API maintenance — being removed in this milestone
+- Full `ibis-backends` test suite compliance — Pure/Legend is more limited than typical SQL backends; existing PyLegend operations must work, full suite compliance is deferred
+- Pure output formatting options — keep generation simple, no pretty-print/indent config
+- Expansion of supported operations beyond what currently works in PyLegend 1.x
+
+## Context
+
+- **Codebase:** See `.planning/codebase/` for full analysis. Current architecture has three parallel API layers (LegendQL, Legacy, Pandas) that all compile to a SQL metamodel, then to vendor SQL. The SQL layer is significant complexity with only the PostgreSQL vendor implemented.
+- **Ibis reference:** `https://github.com/deepyaman/ibis-pandas` shows the pattern for registering a custom Ibis backend. The new backend should follow this registration pattern so it's available as `ibis.legend`.
+- **PCT tests:** PyLegend appears in the Legend PCT (Protocol Conformance Test) matrix. The exact wiring is unclear but must be preserved. Investigate as part of Phase 1.
+- **Pure language:** Capitalized as "Pure" (not PURE) — it is the Legend platform's functional query language, not an acronym. Verify against official Legend documentation during implementation.
+- **Internal library users:** Organizations use an internal library that extends PyLegend's TdsFrame. Those users never interact with PyLegend directly — they call methods on TdsFrame subclasses. The method signatures and behavior of TdsFrame operations are the primary backwards-compatibility surface.
+
+## Constraints
+
+- **Backwards compatibility:** LegendQL API public interface must remain stable (method names, signatures, return types on TdsFrame and its operations). Internal implementation can change freely.
+- **Python support:** Maintain Python 3.9–3.14 compatibility (existing CI matrix).
+- **Ibis:** Must implement as a proper Ibis backend following Ibis's backend registration protocol.
+- **Simplicity:** Prefer fewer abstractions over the current three-layer architecture. Removing the SQL metamodel layer is a desired simplification.
+
+## Key Decisions
+
+| Decision | Rationale | Outcome |
+|----------|-----------|---------|
+| Remove Legacy and Pandas APIs first | Reduces scope; fewer API layers to reconcile during Ibis backend design | — Pending |
+| Ibis backend as primary implementation | Industry-standard Python dataframe API; future-proofs PyLegend for ecosystem interop | — Pending |
+| LegendQL API wraps Ibis backend | Avoids maintaining two separate query-building layers | — Pending |
+| Pure generation only (drop SQL) | SQL compilation was unused complexity; Legend engine accepts Pure natively | — Pending |
+
+## Evolution
+
+This document evolves at phase transitions and milestone boundaries.
+
+**After each phase transition** (via `/gsd-transition`):
+1. Requirements invalidated? → Move to Out of Scope with reason
+2. Requirements validated? → Move to Validated with phase reference
+3. New requirements emerged? → Add to Active
+4. Decisions to log? → Add to Key Decisions
+5. "What This Is" still accurate? → Update if drifted
+
+**After each milestone** (via `/gsd-complete-milestone`):
+1. Full review of all sections
+2. Core Value check — still the right priority?
+3. Audit Out of Scope — reasons still valid?
+4. Update Context with current state
+
+---
+*Last updated: 2026-05-31 after initialization*