thrifty-ml 0.1.0__tar.gz

thrifty_ml-0.1.0/.github/actions/uv_setup/action.yml

@@ -0,0 +1,19 @@
+name: uv-install
+description: Set up Python and uv
+
+inputs:
+  python-version:
+    description: Python version, supporting MAJOR.MINOR only
+    required: true
+
+env:
+  UV_VERSION: "0.5.25"
+
+runs:
+  using: composite
+  steps:
+    - name: Install uv and set the python version
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: ${{ env.UV_VERSION }}
+        python-version: ${{ inputs.python-version }}

thrifty_ml-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,65 @@
+name: Publish to TestPyPI and PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python + uv
+        uses: "./.github/actions/uv_setup"
+        with:
+          python-version: "3.11"
+
+      - name: Build dists
+        run: uv build
+
+      - name: Upload dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-testpypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/thrifty-ml
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          verbose: true
+
+  publish-pypi:
+    needs: publish-testpypi
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/thrifty-ml
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true

thrifty_ml-0.1.0/.gitignore

@@ -0,0 +1,225 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Benchmark outputs
+benchmarks/imdb/results*.json
+benchmarks/imdb/.cache_*/
+
+# Claude Code
+.claude/

thrifty_ml-0.1.0/CLAUDE.md

@@ -0,0 +1,60 @@
+# thrifty-ml
+
+## gstack
+
+Use `/browse` from gstack for all web browsing. Never use `mcp__claude-in-chrome__*` tools.
+
+Available gstack skills:
+- `/office-hours` — office hours facilitation
+- `/plan-ceo-review` — CEO review planning
+- `/plan-eng-review` — engineering review planning
+- `/plan-design-review` — design review planning
+- `/design-consultation` — design consultation
+- `/design-shotgun` — rapid design exploration
+- `/design-html` — HTML design generation
+- `/review` — code review
+- `/ship` — ship a feature
+- `/land-and-deploy` — land and deploy changes
+- `/canary` — canary deployment
+- `/benchmark` — benchmarking
+- `/browse` — headless browser for web browsing and QA
+- `/connect-chrome` — connect to Chrome
+- `/qa` — QA testing
+- `/qa-only` — QA without implementation
+- `/design-review` — design review
+- `/setup-browser-cookies` — configure browser cookies
+- `/setup-deploy` — configure deployment
+- `/setup-gbrain` — configure gbrain
+- `/retro` — retrospective
+- `/investigate` — investigation and debugging
+- `/document-release` — release documentation
+- `/document-generate` — documentation generation
+- `/codex` — codex operations
+- `/cso` — CSO operations
+- `/autoplan` — automated planning
+- `/plan-devex-review` — developer experience review planning
+- `/devex-review` — developer experience review
+- `/careful` — careful mode for risky changes
+- `/freeze` — freeze deployments
+- `/guard` — guard mode
+- `/unfreeze` — unfreeze deployments
+- `/gstack-upgrade` — upgrade gstack
+- `/learn` — learning and documentation
+
+## Skill routing
+
+When the user's request matches an available skill, ALWAYS invoke it using the Skill
+tool as your FIRST action. Do NOT answer directly, do NOT use other tools first.
+The skill has specialized workflows that produce better results than ad-hoc answers.
+
+Key routing rules:
+- Product ideas, "is this worth building", brainstorming → invoke office-hours
+- Bugs, errors, "why is this broken", 500 errors → invoke investigate
+- Ship, deploy, push, create PR → invoke ship
+- QA, test the site, find bugs → invoke qa
+- Code review, check my diff → invoke review
+- Update docs after shipping → invoke document-release
+- Weekly retro → invoke retro
+- Design system, brand → invoke design-consultation
+- Visual audit, design polish → invoke design-review
+- Architecture review → invoke plan-eng-review

thrifty_ml-0.1.0/Design.md

@@ -0,0 +1,251 @@
+# thrifty-ml Design
+
+## What it does
+
+thrifty-ml replaces per-row LLM calls with lightweight ML classifiers ("proxy models") trained on text embeddings. Instead of asking an LLM to evaluate every row in a DataFrame, it:
+
+1. Labels a small sample (~1 000 rows) using the LLM.
+2. Embeds all rows with an embedding model.
+3. Trains a fast classifier (logistic regression, SVM, or LightGBM) on the labeled sample.
+4. Evaluates classifier quality on a holdout split.
+5. If quality is good enough, uses the classifier to label the remaining rows instead of the LLM.
+
+On large datasets this yields 100–1 000× cheaper and faster labeling with accuracy that matches the LLM within a configurable tolerance.
+
+The technique is described in [arXiv 2603.15970](https://arxiv.org/html/2603.15970v6) and is used inside Google's BigQuery `AI.IF` and AlloyDB accelerated functions. thrifty-ml ports it to any Python DataFrame.
+
+---
+
+## Architecture
+
+```
+thrifty_ml/
+├── __init__.py          # Public API: ml_filter, ml_classify, Proxy, EmbeddingBackend
+├── engine.py            # Engine — the orchestration core
+├── sampling.py          # random_sample(): splits df into sample + remainder
+├── evaluator.py         # evaluate(), train_holdout_split()
+├── cache.py             # diskcache wrappers for embeddings and labels
+├── llm.py               # Async LLM labeling via LiteLLM
+├── embeddings.py        # EmbeddingBackend ABC + LiteLLMEmbeddingBackend
+├── cli.py               # Typer CLI (filter, classify, embed, label, cache clear)
+└── proxy/
+    ├── base.py          # ProxyModel ABC (fit, predict, save, load)
+    ├── linear.py        # LogisticRegressionProxy, LinearSVCProxy
+    └── trees.py         # LightGBMProxy
+```
+
+---
+
+## Pipeline
+
+Both online and offline modes share the same core pipeline inside `Engine`:
+
+```
+df
+ │
+ ├─ embed_texts(all rows)  ──────────── cache hit/miss per text ──── diskcache
+ │
+ ├─ random_sample(sample_size)
+ │      │
+ │      └─ label_texts(sample) ─────── LLM calls (async, batched) ── diskcache
+ │
+ ├─ train_holdout_split(labeled sample)
+ │      │  80 % train / 20 % holdout (stratified when possible)
+ │      │
+ │      └─ proxy.fit(X_train, y_train)
+ │
+ ├─ evaluate(proxy, X_holdout, y_holdout)
+ │      │  proxy_f1 >= 1.0 - τ  →  use_proxy = True
+ │      │  otherwise emit UserWarning and fall back to LLM
+ │      │
+ │      └─ τ = fallback_threshold (default 0.1)
+ │
+ └─ predict remainder
+        if use_proxy:  proxy.predict(X_remainder)
+        else:          label_texts(remainder)   ← full LLM cost
+```
+
+**Online mode** (`ml_filter` / `ml_classify`) runs the whole pipeline and returns labels for every row.
+
+**Offline mode** (`Proxy.fit` / `Proxy.predict`) runs up to and including `proxy.fit`, then serializes the trained model. `predict()` only embeds + classifies — no LLM calls in the hot path.
+
+---
+
+## Key components
+
+### Engine (`engine.py`)
+
+Accepts a prompt, LLM model string, embedding backend, and proxy type. Coordinates all pipeline stages. Two entry points:
+
+- `run(df, text_column)` — online, returns a label array for the full DataFrame.
+- `fit(df, text_column)` — offline, returns `(proxy_model, eval_result)` for serialization.
+
+`_run_async(coro)` is a small helper that makes the async LLM calls work in any context — plain scripts use `asyncio.run()`, Jupyter notebooks (which already have a running loop) use `nest_asyncio` if available, or fall back to a `ThreadPoolExecutor` to avoid `RuntimeError: This event loop is already running`.
+
+### Sampling (`sampling.py`)
+
+`random_sample(df, n, seed)` returns `(sample_df, remainder_df)`. If `n >= len(df)` the entire DataFrame is the sample and remainder is empty (LLM labels are returned directly, no proxy needed).
+
+### Evaluator (`evaluator.py`)
+
+`train_holdout_split(X, y, holdout_fraction=0.2)` uses `StratifiedShuffleSplit` when all classes have ≥ 2 samples; falls back to a random permutation when the sample is too small to stratify.
+
+`evaluate(proxy, X_train, y_train, X_holdout, y_holdout, fallback_threshold)`:
+
+- Fits the proxy on the train split.
+- Computes `proxy_f1` using `f1_score` with `average="binary"` for two-class problems and `"macro"` for three or more. The `average` is determined from the **union** of train and holdout labels, so a class that only appears in holdout does not cause a crash.
+- Compares `proxy_f1 >= 1.0 - fallback_threshold`. Because LLM labels are used as ground truth, the LLM's own F1 is trivially 1.0.
+- Emits a `UserWarning` and sets `use_proxy=False` on failure.
+
+### LLM labeling (`llm.py`)
+
+`label_texts(texts, prompt, model, classes, max_concurrency, cache_dir)` is an async function. It fires one coroutine per text, throttled by an `asyncio.Semaphore`. Each call:
+
+1. Checks the label cache.
+2. On a miss: calls `litellm.acompletion` with `response_format={"type": "json_object"}` and `temperature=0`.
+3. For binary mode (no `classes`): parses `{"label": true/false}`.
+4. For multiclass: parses `{"label": "<class>"}` and returns `"__unknown__"` if the value is not in the allowed list.
+5. Writes the result to the label cache.
+
+Retries on transient errors are handled by `_litellm_call_with_retry` in `_utils.py`.
+
+### Embeddings (`embeddings.py`)
+
+`EmbeddingBackend` is an ABC with two requirements:
+
+- `model_id: str` — stable string used as the diskcache key.
+- `embed(texts: list[str]) -> np.ndarray` — returns a float32 array of shape `(n, dim)`.
+
+`LiteLLMEmbeddingBackend(model: str)` is the default implementation. It sends texts to any LiteLLM-supported embedding provider in chunks of 2 048.
+
+`embed_texts(texts, backend, cache_dir)` does cache-then-fill: checks the cache for each text, collects misses, calls `backend.embed()` once for all misses, and writes results back. A warning is emitted for inputs exceeding 250 000 texts (memory risk).
+
+Custom backends — sentence-transformers, pre-computed vectors, proprietary APIs — implement `EmbeddingBackend` and pass an instance anywhere a model string is accepted.
+
+### Proxy models (`proxy/`)
+
+`ProxyModel` ABC (`base.py`) defines `fit(X, y)`, `predict(X)`, optional `predict_proba(X)`, and default `save`/`load` via `joblib`.
+
+| Class | Backend | Imbalance handling | `save`/`load` |
+|---|---|---|---|
+| `LogisticRegressionProxy` | sklearn `LogisticRegression` | `class_weight="balanced"` | joblib |
+| `LinearSVCProxy` | sklearn `LinearSVC` | `class_weight="balanced"` | joblib |
+| `LightGBMProxy` | LightGBM `LGBMClassifier` | `is_unbalance=True` | LightGBM booster text format |
+
+`LightGBMProxy` overrides `save`/`load` to use the LightGBM native booster format (not joblib), since joblib-serialized LightGBM objects are not portable across LightGBM versions.
+
+### Caching (`cache.py`)
+
+All embeddings and labels are cached in a `diskcache.FanoutCache` (8 SQLite shards, 60 s timeout) at `~/.cache/thrifty_ml/` by default.
+
+Cache keys are namespaced by version: `thrifty_ml/{VERSION}/...`
+
+- **Embedding key**: `emb / sha256(text) / model_id`
+- **Label key**: `lbl / sha256(text) / sha256(prompt) / model_id / classes_key`
+
+`classes_key` is `"binary"` when no classes are provided, or `sha256(sorted(classes))` for multiclass. This ensures that cached binary labels are not reused for a multiclass query on the same text+prompt, and vice versa.
+
+### `Proxy` save/load (`__init__.py`)
+
+`Proxy.save(path)` writes two files:
+
+- `path` — the serialized proxy model (joblib or LightGBM native).
+- `path.meta.json` — a sidecar: `{"proxy_type": "lr"|"svc"|"lgbm", "embedding_model": "<model_id>"}`.
+
+`Proxy.load(path, embedding_model=None)` reads the sidecar to determine the proxy type and embedding model, then dispatches to the correct backend's `load()`. If `embedding_model` is passed explicitly it overrides the sidecar value (required for custom `EmbeddingBackend` subclasses, since only a string model ID is stored in the sidecar).
+
+---
+
+## Public API
+
+```python
+from thrifty_ml import ml_filter, ml_classify, Proxy, EmbeddingBackend
+
+# Online binary filter
+mask = ml_filter(
+    df,
+    prompt="Is this review positive?",
+    text_column="review",
+    llm="anthropic/claude-haiku-4-5",
+    embedding_model="text-embedding-3-small",
+    proxy="lr",               # "lr" | "svc" | "lgbm"
+    sample_size=1000,
+    fallback_threshold=0.1,   # τ: proxy F1 must be >= 1.0 - τ
+)
+
+# Online multiclass
+labels = ml_classify(
+    df,
+    prompt="Classify support ticket intent",
+    text_column="body",
+    llm="anthropic/claude-haiku-4-5",
+    embedding_model="text-embedding-3-small",
+    classes=["billing", "tech", "other"],
+)
+
+# Offline sklearn-style
+proxy = Proxy(prompt="...", llm="...", embedding_model="...", model="lgbm")
+proxy.fit(train_df, "text")
+proxy.save("proxy.lgbm")
+
+loaded = Proxy.load("proxy.lgbm")
+preds = loaded.predict(new_df, "text")   # no LLM calls
+
+# Custom embedding backend
+class MyBackend(EmbeddingBackend):
+    model_id = "my-model-v1"
+    def embed(self, texts):
+        ...  # return np.ndarray of shape (len(texts), dim)
+
+mask = ml_filter(df, ..., embedding_model=MyBackend())
+```
+
+---
+
+## CLI
+
+```
+thrifty-ml filter   input.parquet --prompt "..." --text-col review --out mask.parquet
+thrifty-ml classify input.parquet --prompt "..." --text-col review --classes a,b,c --out labels.parquet
+thrifty-ml embed    input.parquet --text-col review --model text-embedding-3-small --out embeds.npy
+thrifty-ml label    input.parquet --prompt "..." --text-col review --sample 1000 --out labels.parquet
+thrifty-ml cache clear
+```
+
+All commands accept `--llm`, `--embedding-model`, `--proxy`, `--cache-dir`, `--sample-size`, `--fallback-threshold`, `--max-concurrency`, `--seed`. Input formats: `.parquet`, `.csv`, `.json`, `.jsonl`.
+
+---
+
+## Design decisions
+
+**Why logistic regression as the default proxy?** Embedding models are trained to produce linearly separable representations. The paper's own ablation finds that LR almost always matches or beats more complex classifiers when using modern embeddings. LR trains in seconds on 1 000 samples and infers in < 1 ms per batch.
+
+**Why LightGBM for non-linear tasks?** Histogram-based splits are fast on dense float32 arrays, training is low-memory, and the install is lightweight. It handles class imbalance natively via `is_unbalance=True`.
+
+**Why a separate sidecar file for `save`/`load`?** LightGBM and sklearn use different serialization formats (LightGBM native vs joblib). Storing proxy type and embedding model in a `.meta.json` sidecar lets `Proxy.load()` self-describe and dispatch correctly without requiring callers to remember or pass the original arguments.
+
+**Why include `classes` in the label cache key?** A binary filter (`ml_filter`) and a multiclass classifier (`ml_classify`) can share the same prompt and model. Without a `classes` component in the key, a cached binary `True`/`False` label could be silently returned for a multiclass query expecting `"billing"` / `"tech"` / `"other"`.
+
+**Why `_run_async` instead of `asyncio.run` everywhere?** `asyncio.run()` raises `RuntimeError: This event loop is already running` inside Jupyter notebooks and async frameworks like FastAPI. `_run_async` detects a running loop and either patches it with `nest_asyncio` or offloads to a thread, making the library usable without any setup from the caller.
+
+**Fallback threshold τ.** The paper reports that τ = 0.1 (i.e., proxy F1 ≥ 0.9 of LLM F1) covers > 95% of production use cases. The default is 0.1 but it is user-configurable. Setting τ = 0.0 means the proxy must achieve perfect F1 on the holdout, which will almost always fall back to the LLM.
+
+---
+
+## Advantages over the SQL approach (BigQuery AI.IF / AlloyDB)
+
+The paper's technique is implemented as SQL functions inside Google's data warehouse products — `AI.IF` in BigQuery and accelerated functions in AlloyDB. That surface imposes several constraints that thrifty-ml removes.
+
+**No infrastructure dependency.** The SQL approach requires data to be in BigQuery or AlloyDB, a GCP account, and quota. thrifty-ml works on any DataFrame — pandas, a local parquet file, a CSV — with no cloud account required. The technique is available to anyone running Python.
+
+**Any LLM and any embedding provider.** BigQuery and AlloyDB are wired to specific Google models (Vertex AI / Gemini). thrifty-ml uses LiteLLM as the adapter layer, so the same code path works with Anthropic, OpenAI, Bedrock, Vertex, a local Ollama instance, or any LiteLLM-supported provider. The embedding backend is similarly pluggable via the `EmbeddingBackend` ABC — you can bring pre-computed vectors, a fine-tuned sentence-transformer, or a proprietary embedding API.
+
+**Offline / deploy-once mode.** SQL functions re-run the sample-label-train pipeline on each query invocation. thrifty-ml's `Proxy` class separates `fit` from `predict`: you train once, serialize to disk (`proxy.joblib` + `.meta.json` sidecar), and deploy the classifier independently. Subsequent predictions make zero LLM calls and run at classifier speed (~0.1 ms / 1 000 rows for logistic regression).
+
+**Observability and control.** Inside a SQL function you cannot inspect intermediate results. In thrifty-ml, `EvalResult` exposes `proxy_f1`, `llm_f1`, `use_proxy`, and `holdout_size` after every run. You can tune `fallback_threshold` explicitly, inspect the trained sklearn/LightGBM object, check holdout predictions, or step through the pipeline in a notebook. The SQL surface hides all of this.
+
+**Integration with the Python ML ecosystem.** Because proxy models are sklearn or LightGBM objects, standard tooling applies directly — feature importances, calibration, cross-validation, SHAP explanations, model registries. None of that is available through a SQL function.
+
+**Iterative development workflow.** A data scientist iterating on a prompt or embedding model has a much tighter feedback loop in Python — run in a notebook, inspect the sample labels, check the proxy F1, adjust, re-run — versus having to push data to a warehouse, re-run a SQL query, and parse results from a table each iteration.
+
+The cost and latency wins described in the paper (300–1 000× reduction at 10M-row scale) transfer fully to thrifty-ml because the underlying technique is identical. The difference is that thrifty-ml makes those wins available without requiring a Google data warehouse.

thrifty_ml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Derrick Kondo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.