metadata_version string | name string | version string | summary string | description string | description_content_type string | author string | author_email string | maintainer string | maintainer_email string | license string | keywords string | classifiers list | platform list | home_page string | download_url string | requires_python string | requires list | provides list | obsoletes list | requires_dist list | provides_dist list | obsoletes_dist list | requires_external list | project_urls list | uploaded_via string | upload_time timestamp[us] | filename string | size int64 | path string | python_version string | packagetype string | comment_text string | has_signature bool | md5_digest string | sha256_digest string | blake2_256_digest string | license_expression string | license_files list | recent_7d_downloads int64 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2.4 | modelbenchx | 1.0.5 | A lightweight toolkit for benchmarking ML model inference performance. | # ModelBenchX: ML Inference Benchmarking Toolkit
A lightweight, extensible toolkit for benchmarking ML model inference
performance.
ModelBenchX is designed for ML engineers who need quick and reliable
measurements of:
- Inference latency
- Throughput (requests/sec)
- Memory usage
- Model performance comparison
- Automated Markdown report generation
------------------------------------------------------------------------
## 🚀 Installation
``` bash
pip install modelbenchx
```
------------------------------------------------------------------------
## 🧩 Requirements
Component Version
------------ -----------------------
Python 3.9 -- 3.11
OS Linux, macOS, Windows
Dependency psutil
ModelBenchX is continuously tested against:
- Python 3.9\
- Python 3.10\
- Python 3.11
------------------------------------------------------------------------
## ⚡ Quick Example
``` python
from modelbench import benchmark_model
import numpy as np
def model(x):
return x * 2
input_data = np.array([1, 2, 3])
results = benchmark_model(model, input_data, runs=200)
print(results)
```
------------------------------------------------------------------------
## 🔍 Comparing Multiple Models
``` python
from modelbench import compare_models
import numpy as np
import time
def fast_model(x):
return x
def slow_model(x):
time.sleep(0.01)
return x
models = {
"FastModel": fast_model,
"SlowModel": slow_model
}
input_data = np.array([1])
results = compare_models(models, input_data, runs=100)
for name, metrics in results.items():
print(name, metrics)
```
------------------------------------------------------------------------
## 📄 Generate Benchmark Report
``` python
from modelbench.report import generate_markdown_report
generate_markdown_report(results)
```
This creates:
benchmark_report.md
------------------------------------------------------------------------
## 🛠 CLI Usage
Benchmark pickled models directly from the command line:
``` bash
modelbench --model model.pkl --input input.pkl --runs 200
```
------------------------------------------------------------------------
## 📐 Benchmarking Methodology
ModelBenchX follows a consistent benchmarking approach:
- Warm-up runs to reduce cold-start bias
- High-resolution timing using `time.perf_counter()`
- Memory tracking via process RSS measurement
- Throughput calculated as total runs / total execution time
⚠ Microsecond-level latency measurements may include Python loop
overhead.\
For production-critical benchmarking, batch benchmarking is recommended
(planned in v1.1).
------------------------------------------------------------------------
## 📦 Versioning & Stability
ModelBenchX follows Semantic Versioning:
- MAJOR → Breaking API changes
- MINOR → New features
- PATCH → Bug fixes & improvements
The public API (`benchmark_model`, `compare_models`) is considered
stable as of v1.0.x.
------------------------------------------------------------------------
## 🧪 Testing & CI
ModelBenchX includes automated unit tests covering:
- Core benchmarking engine\
- Model comparison logic\
- Metric structure validation
Continuous Integration runs on:
- Python 3.9\
- Python 3.10\
- Python 3.11
Run tests locally:
``` bash
pip install -e .
pip install pytest
pytest
```
------------------------------------------------------------------------
## 🎯 Ideal Use Cases
- Model optimization workflows
- Latency-sensitive systems
- Edge deployment benchmarking
- ML infrastructure experimentation
- Performance regression detection
------------------------------------------------------------------------
## 🗺 Roadmap
### v1.1 (Planned)
- Batch size benchmarking
- Peak memory tracking
- JSON + HTML reporting support
- Extended framework adapters (PyTorch / TensorFlow)
### Future
- GPU benchmarking support
- Visualization utilities
- Async benchmarking
- Dockerized benchmarking mode
------------------------------------------------------------------------
## 🤝 Contributing
Contributions are welcome.
Please read CONTRIBUTING.md before submitting pull requests.
------------------------------------------------------------------------
## 📜 License
This project is licensed under the MIT License.
| text/markdown | Praveen Amujuri | null | null | null | null | machine learning, mlops, benchmarking, inference, performance | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Operating System :: OS Independent",
"Intended Audience :: Developers",
"Topic :: Software Development :: Testing",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"psutil",
"numpy"
] | [] | [] | [] | [
"Homepage, https://github.com/PraveenAmujuri/modelbenchx",
"Repository, https://github.com/PraveenAmujuri/modelbenchx",
"Issues, https://github.com/PraveenAmujuri/modelbenchx/issues"
] | twine/6.2.0 CPython/3.10.0 | 2026-02-21T04:55:28.875528 | modelbenchx-1.0.5.tar.gz | 5,950 | 14/b7/b282f6ff020718ab5f5e258e2a04177a79389d4ef4fa6b81099528ed9b0d/modelbenchx-1.0.5.tar.gz | source | sdist | null | false | 803b0baabe3525199fbbe4355ef1219c | 70ec96957f529a3bb0ddd7dcebff1fa07b5f602f8f0951bfa77382974d34544f | 14b7b282f6ff020718ab5f5e258e2a04177a79389d4ef4fa6b81099528ed9b0d | MIT | [
"LICENSE"
] | 222 |
2.4 | calt-x | 1.0.3 | A library for computational algebra using Transformers | # CALT: Computer ALgebra with Transformer
[](https://hiroshikera.github.io/calt/)
[](https://hiroshikera.github.io/calt/)
> 📖 **📚 [View Full Documentation](https://hiroshikera.github.io/calt/)**
## Overview
CALT is a simple Python library for learning arithmetic and symbolic computation with a Transformer model (a deep neural model to realize sequence-to-sequence functions).
It offers a basic Transformer model and training, and non-experts of deep learning (e.g., mathematicians) can focus on constructing datasets to train and evaluate the model. Particularly, users only need to implement an instance generator for their own task.
For example, users define the following code for the polynomial addition task.
```python
class PolynomialAdditionGenerator:
# Task - input: F=[f_1, ..., f_s], target: G=[g:= f_1+...+f_s]
def __init__(
self, sampler: PolynomialSampler, max_polynomials: int, min_polynomials: int
):
self.sampler = sampler
self.max_polynomials = max_polynomials
self.min_polynomials = min_polynomials
def __call__(self, seed: int) -> Tuple[List[PolyElement], PolyElement]:
random.seed(seed) # Set random seed
num_polys = random.randint(self.min_polynomials, self.max_polynomials)
F = self.sampler.sample(num_samples=num_polys)
g = sum(F)
return F, g
```
CALT automatically calls this generator in parallel to efficiently construct large datasets and trains a Transformer model to learn the computation. The sample generation process itself can reveal unexplored mathematical problems, enabling researchers to study their theoretical and algorithmic solutions. The following is a small list of such studies from our group.
- ["Learning to Compute Gröbner Bases," Kera et al., 2024](https://arxiv.org/abs/2311.12904)
- ["Computational Algebra with Attention: Transformer Oracles for Border Basis Algorithms," Kera and Pelleriti et al., 2025](https://arxiv.org/abs/2505.23696)
- ["Geometric Generality of Transformer-Based Gröbner Basis Computation," Kambe et al., 2025](https://arxiv.org/abs/2504.12465)
Refer to our paper ["CALT: A Library for Computer Algebra with Transformer," Kera et al., 2025](https://arxiv.org/abs/2506.08600) for a comprehensive overview.
## 🚀 Quick Start
### Basic Installation
```bash
pip install calt-x
```
### For Research Projects
For researchers and developers who want to start experiments with CALT, we provide the [CALT codebase](https://github.com/HiroshiKERA/calt-codebase) - a comprehensive template repository with pre-configured environment and development tools.
```bash
git clone https://github.com/HiroshiKERA/calt-codebase.git
cd calt-codebase
conda env create -f environment.yml
```
## 📖 Documentation & Resources
- **📚 [Full Documentation](https://hiroshikera.github.io/calt/)** - Complete guide with quickstart and project organization tips
- **⚡ [Quickstart Guide](https://hiroshikera.github.io/calt-codebase/quickstart/)** - Get up and running quickly
- **📓 [Demo Notebook](https://colab.research.google.com/github/HiroshiKERA/calt/blob/dev/examples/demos/minimal_demo.ipynb)** - Interactive examples
## 🔗 Links
- [📖 Documentation](https://hiroshikera.github.io/calt/)
- [🐛 Issues](https://github.com/HiroshiKERA/calt/issues)
- [💬 Discussions](https://github.com/HiroshiKERA/calt/discussions)
## Citation
If you use this code in your research, please cite our paper:
```bibtex
@misc{kera2025calt,
title={CALT: A Library for Computer Algebra with Transformer},
author={Hiroshi Kera and Shun Arawaka and Yuta Sato},
year={2025},
archivePrefix={arXiv},
eprint={2506.08600}
}
```
| text/markdown | null | Hiroshi Kera <kera.hiroshi@gmail.com>, Yuta Sato <sato.yuta@gmail.com>, Shun Arakawa <shun.arkw@gmail.com> | null | null | null | null | [] | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"transformers>=4.49.0",
"omegaconf>=2.3.0",
"torch>=2.6.0",
"wandb>=0.15.11",
"accelerate>=0.29.0",
"joblib>=1.5.0",
"sympy>=1.12",
"IPython>=8.18.1"
] | [] | [] | [] | [
"Source, https://github.com/HiroshiKERA/calt",
"Issues, https://github.com/HiroshiKERA/calt/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:55:05.745033 | calt_x-1.0.3.tar.gz | 83,791 | 1b/b8/aa280e3a4715096888d92c75a1e4a24bb3182b09371e61da6e41710424d3/calt_x-1.0.3.tar.gz | source | sdist | null | false | 867a323f0e539e009e6897a4658a5d06 | 1b012584c4d16cb243868778ce8ef55365cde664dc102322d50d27eb3b9ca9d1 | 1bb8aa280e3a4715096888d92c75a1e4a24bb3182b09371e61da6e41710424d3 | null | [
"LICENSE"
] | 229 |
2.4 | otterai-cli | 0.1.2 | Unofficial Otter.ai CLI | # otterai-cli
An unofficial command-line interface for [Otter.ai](https://otter.ai).
> **Note:** This project is not affiliated with or endorsed by Otter.ai / Aisense Inc.
## Requirements
- Python 3.10+
## Installation
```bash
uv tool install otterai-cli
```
This makes the `otter` command available globally.
To update to the latest version:
```bash
uv tool upgrade otterai-cli
```
Or run directly without installing:
```bash
uvx --from otterai-cli otter --help
```
## Setup
```bash
otter login
```
Credentials are stored in your OS keychain (macOS Keychain, Windows Credential Locker, etc.) via [keyring](https://pypi.org/project/keyring/), with `~/.otterai/config.json` as fallback.
You can also use environment variables (`OTTERAI_USERNAME`, `OTTERAI_PASSWORD`), which take highest precedence.
### Auth commands
```bash
otter user # check current user
otter logout # remove saved credentials
```
## Usage
```bash
otter speeches list # list all speeches
otter speeches list --days 7 # last 7 days
otter speeches list --folder "Work" # by folder name
otter speeches get SPEECH_ID # get speech details + transcript
otter speeches download SPEECH_ID -f txt # download as txt, pdf, mp3, docx, srt, or md
otter speeches search "keyword" SPEECH_ID # search within a speech
otter speakers list # list all speakers
otter folders list # list all folders
```
Run `otter --help` or `otter <command> --help` for more options.
### Important: Speech IDs (otid vs speech_id)
Otter.ai speeches have two identifiers:
- **`speech_id`** (e.g. `22WB27HAEBEJYFCA`) -- internal ID, does **NOT** work with API endpoints
- **`otid`** (e.g. `jqb7OHo6mrHtCuMkyLN0nUS8mxY`) -- the ID used in all API calls
All CLI commands that accept a `SPEECH_ID` argument expect the **otid** value. Use `otter speeches list` to find otids, or `otter speeches list --json | jq '.speeches[].otid'` for just the IDs.
### Speeches
```bash
# List all speeches
otter speeches list
# List with options
otter speeches list --page-size 10 --source owned
# List speeches from the last N days
otter speeches list --days 2
# List speeches in a specific folder (by name or ID)
otter speeches list --folder "CoverNode"
# Get a specific speech
otter speeches get SPEECH_ID
# Search within a speech
otter speeches search "search query" SPEECH_ID
# Download a speech (formats: txt, pdf, mp3, docx, srt, md)
otter speeches download SPEECH_ID --format txt
# Download as markdown (generated locally from transcript data)
otter speeches download SPEECH_ID --format md
otter speeches download SPEECH_ID --format md --output meeting-notes
otter speeches download SPEECH_ID --format md --frontmatter-fields "title,summary,speakers,start_time,end_time,duration_seconds,source,speech_id,folder,folder_id"
# Upload an audio file
otter speeches upload recording.mp4
# Move to trash
otter speeches trash SPEECH_ID
# Rename a speech
otter speeches rename SPEECH_ID "New Title"
# Move speeches to a folder (by name or ID)
otter speeches move SPEECH_ID --folder "CoverNode"
otter speeches move ID1 ID2 ID3 --folder "CoverNode"
# Move to a new folder (auto-create if it doesn't exist)
otter speeches move SPEECH_ID --folder "New Folder" --create
```
#### Markdown frontmatter (`--format md`)
Markdown export includes YAML frontmatter, configurable per download:
```bash
# Use defaults
otter speeches download SPEECH_ID --format md
# Pick exact fields (in your own order)
otter speeches download SPEECH_ID --format md --frontmatter-fields "title,speech_id,summary"
# Disable all frontmatter fields
otter speeches download SPEECH_ID --format md --frontmatter-fields none
```
Default frontmatter fields (in order):
1. `title`
2. `summary`
3. `speakers`
4. `start_time`
5. `end_time`
6. `duration_seconds`
7. `source`
8. `speech_id`
9. `folder`
10. `folder_id`
Available frontmatter fields for `--frontmatter-fields`:
- `title`
- `summary`
- `speakers`
- `start_time`
- `end_time`
- `duration_seconds`
- `source`
- `speech_id`
- `folder`
- `folder_id`
- `otid`
- `created_at`
- `transcript_updated_at`
- `language`
- `transcript_count`
- `process_status`
Notes:
- `--frontmatter-fields` is valid only with `--format md`.
- `speech_id` in frontmatter is the Otter internal `speech_id`; command argument `SPEECH_ID` still expects the `otid`.
### Speakers
```bash
# List all speakers
otter speakers list
# Create a new speaker
otter speakers create "Speaker Name"
# Tag a speaker on transcript segments
otter speakers tag SPEECH_ID SPEAKER_ID
otter speakers tag SPEECH_ID SPEAKER_ID --all
```
### Folders and Groups
```bash
# List folders
otter folders list
# Create a folder
otter folders create "My Folder"
# Rename a folder
otter folders rename FOLDER_ID "New Name"
# List groups
otter groups list
```
### Configuration
```bash
# Show current config
otter config show
# Clear saved config
otter config clear
```
### JSON Output
Most commands support `--json` flag for machine-readable output:
```bash
otter speeches list --json
otter speakers list --json
```
## Development
```bash
uv sync --dev # install dependencies
uv run pytest # run tests
```
## Acknowledgements
Based on [gmchad/otterai-api](https://github.com/gmchad/otterai-api) by Chad Lohrli, with CLI functionality from [PR #9](https://github.com/gmchad/otterai-api/pull/9) by [@andrewfurman](https://github.com/andrewfurman).
## License
MIT
| text/markdown | null | Eric Chan <eric.kahei.chan@gmail.com> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: End Users/Desktop",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Utilities"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"click>=8.0",
"keyring>=23.0",
"requests",
"requests-toolbelt",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"responses; extra == \"dev\"",
"ruff; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/ericchan-su/otterai-cli",
"Repository, https://github.com/ericchan-su/otterai-cli",
"Issues, https://github.com/ericchan-su/otterai-cli/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:53:51.019729 | otterai_cli-0.1.2.tar.gz | 82,632 | fe/bd/80ad3dbbd95485b989c576817043d3e67e2cb794080224c6835d3a5742e1/otterai_cli-0.1.2.tar.gz | source | sdist | null | false | 64e93162d36607b32f25fa1f2e43ddb4 | fc99e0b90500740b7be2a68bfd4c92f2ccd135818285073fce82ed3e354dc55f | febd80ad3dbbd95485b989c576817043d3e67e2cb794080224c6835d3a5742e1 | MIT | [
"LICENSE"
] | 212 |
2.4 | senoquant | 1.0.0b7 | napari plugin for spatial quantification of senescence markers in tissue imaging | # SenoQuant
[](https://badge.fury.io/py/senoquant)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/BSD-3-Clause)
SenoQuant is a versatile [napari](https://napari.org/stable/index.html) plugin designed for comprehensive, accurate,
and unbiased spatial quantification and prediction of senescence markers
across diverse tissue contexts.
## Features
- Read microscopy formats via BioIO, including OME-TIFF, ND2, LIF, CZI, and more.
- Segment nuclei and cytoplasm with built-in models, including StarDist, Cellpose SAM, and morphological operations.
- Detect punctate spots with built-in detectors.
- Run prediction models for senescence-associated feature maps in a dedicated Prediction tab (includes `demo_model` placeholder).
- Quantify marker intensity, morphology, spot counts, and spot colocalization.
- Generate visualization outputs from quantification tables (Spatial Plot, UMAP, Double Expression, and Neighborhood Enrichment).
- Run batch workflows across folders with multi-scene support.
- Save/load reusable Segmentation, Spots, and Batch settings for reproducibility.
## Installation
### Installer (recommended - please also use Google Chrome to download)
#### Windows
Download the Windows installer (`.exe`) from the [latest release](https://github.com/HaamsRee/senoquant/releases/latest) under "Assets."
#### macOS
Download the macOS installer (`.pkg`) from the [latest release](https://github.com/HaamsRee/senoquant/releases/latest) under "Assets."
#### Linux
Installer support for Linux is under construction.
> **Note 1:** The installer may trigger security warnings on macOS and Windows (especially when using Microsoft Edge). This is expected for open-source software distributed outside of official app stores. Follow the system prompts to allow installation. On Windows, you may need to click "More info" and then "Run anyway" on the warning popup. On macOS, when you see the warning that "Apple could not verify...," click "Done" to dismiss, then go to System Settings > Privacy & Security and click "Open Anyway" for the SenoQuant installer.
> **Note 2:** In some corporate environments, security policies may block the installer's access to folders or the Internet. If you encounter issues, try running the installer with administrator privileges (right-click > "Run as administrator" on Windows) and ensure that your firewall allows the installer to access the Internet to download dependencies.
### Manual installation
For conda/pip/uv setup, see the [developer installation guide](https://haamsree.github.io/senoquant/developer/installation/).
## Quick start
Use the documentation workflow for the most up-to-date instructions.
- Start with the [installation guide](https://haamsree.github.io/senoquant/user/installation/).
- Follow the [quick start guide](https://haamsree.github.io/senoquant/user/quickstart/).
- Then use tab-specific guides for [segmentation](https://haamsree.github.io/senoquant/user/segmentation/), [spots](https://haamsree.github.io/senoquant/user/spots/), [prediction](https://haamsree.github.io/senoquant/user/prediction/), [quantification](https://haamsree.github.io/senoquant/user/quantification/), [visualization](https://haamsree.github.io/senoquant/user/visualization/), [batch](https://haamsree.github.io/senoquant/user/batch/), and [settings](https://haamsree.github.io/senoquant/user/settings/).
## Documentation
Full documentation is available at [https://haamsree.github.io/senoquant/](https://haamsree.github.io/senoquant/).
- [Installation guide](https://haamsree.github.io/senoquant/user/installation/).
- [Quick start tutorial](https://haamsree.github.io/senoquant/user/quickstart/).
- [Segmentation models](https://haamsree.github.io/senoquant/user/segmentation/).
- [Spot detection](https://haamsree.github.io/senoquant/user/spots/).
- [Prediction tab](https://haamsree.github.io/senoquant/user/prediction/).
- [Quantification features](https://haamsree.github.io/senoquant/user/quantification/).
- [Visualization tab](https://haamsree.github.io/senoquant/user/visualization/).
- [Batch processing](https://haamsree.github.io/senoquant/user/batch/).
- [Settings persistence](https://haamsree.github.io/senoquant/user/settings/).
- [Prediction model development](https://haamsree.github.io/senoquant/developer/prediction/).
- [API reference](https://haamsree.github.io/senoquant/api/).
## Development
See the [contributing guide](https://haamsree.github.io/senoquant/developer/contributing/) for development setup instructions.
## How to cite
If you use SenoQuant in your research, please cite it using the metadata in `CITATION.cff`.
On GitHub, open the repository page and click `Cite this repository` in the right sidebar to copy a formatted citation.
## Acknowledgements
SenoQuant builds on and integrates excellent open-source projects.
- [napari](https://napari.org/).
- [StarDist](https://github.com/stardist/stardist).
- [Cellpose](https://github.com/MouseLand/cellpose).
- [U-FISH](https://github.com/UFISH-Team/U-FISH).
- [BioIO](https://github.com/bioio-devs/bioio).
| text/markdown | SenoQuant Contributors | null | SenoQuant Contributors | null | BSD-3-Clause | napari, plugin, senescence, quantification, microscopy, image analysis, segmentation, spot detection | [
"Development Status :: 4 - Beta",
"Framework :: napari",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering :: Bio-Informatics",
"Topic :: Scientific/Engineering :: Image Processing"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"bioio>=3.2.0",
"bioio-bioformats>=1.3.0",
"scyjava>=1.12.0",
"numpy<=1.26.4,>=1.23",
"pandas>=2.0",
"cellpose==4.0.8",
"onnx>=1.16",
"onnxruntime>=1.21.0; platform_system == \"Darwin\"",
"onnxruntime-gpu>=1.21.0; platform_system != \"Darwin\"",
"openpyxl>=3.1",
"huggingface_hub>=0.23.0",
"scikit-image<0.25,>=0.22",
"PyWavelets>=1.5",
"scipy>=1.8",
"senoquant-stardist-ext>=0.1.1",
"dask[array]>=2024.4",
"dask[distributed]>=2024.4",
"fsspec>=2024.4",
"smbprotocol>=1.13",
"matplotlib>=3.8",
"umap-learn>=0.5",
"jsonschema>=3.2",
"zarr>=3",
"napari[all]; extra == \"all\"",
"bioio>=3.2.0; extra == \"all\"",
"bioio-bioformats>=1.3.0; extra == \"all\"",
"scyjava>=1.12.0; extra == \"all\"",
"numpy<=1.26.4,>=1.23; extra == \"all\"",
"pandas>=2.0; extra == \"all\"",
"cellpose==4.0.8; extra == \"all\"",
"onnx>=1.16; extra == \"all\"",
"onnxruntime>=1.21.0; platform_system == \"Darwin\" and extra == \"all\"",
"onnxruntime-gpu>=1.21.0; platform_system != \"Darwin\" and extra == \"all\"",
"openpyxl>=3.1; extra == \"all\"",
"huggingface_hub>=0.23.0; extra == \"all\"",
"scikit-image<0.25,>=0.22; extra == \"all\"",
"PyWavelets>=1.5; extra == \"all\"",
"scipy>=1.8; extra == \"all\"",
"senoquant-stardist-ext>=0.1.1; extra == \"all\"",
"dask[array]>=2024.4; extra == \"all\"",
"dask[distributed]>=2024.4; extra == \"all\"",
"fsspec>=2024.4; extra == \"all\"",
"smbprotocol>=1.13; extra == \"all\"",
"matplotlib>=3.8; extra == \"all\"",
"umap-learn>=0.5; extra == \"all\"",
"jsonschema>=3.2; extra == \"all\"",
"zarr>=3; extra == \"all\""
] | [] | [] | [] | [
"Homepage, https://github.com/HaamsRee/senoquant",
"Documentation, https://haamsree.github.io/senoquant/",
"Repository, https://github.com/HaamsRee/senoquant",
"Bug Tracker, https://github.com/HaamsRee/senoquant/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:53:16.929956 | senoquant-1.0.0b7-py3-none-any.whl | 427,192 | 50/a3/cf916d16ede22b19b2fc083c0a7675e592ccb742291e98eaf8a069642716/senoquant-1.0.0b7-py3-none-any.whl | py3 | bdist_wheel | null | false | c9d34c67caf6ceef0fe375970a823545 | 2587e629739b660017e91c4c65f02b02b2bf1d47efcdb074129252c8ac94f556 | 50a3cf916d16ede22b19b2fc083c0a7675e592ccb742291e98eaf8a069642716 | null | [
"LICENSE"
] | 77 |
2.4 | lechange | 0.1.0 | Ultra-fast Git change detection powered by Rust | # Le Change
Fast Git change detection with deploy matrix generation.
Rust core library with a CLI binary, GitHub Action, and Python bindings.
## Features
- Diff two commits and list changed files by type (added, modified, deleted, renamed)
- Glob pattern filtering and exclusion
- Dynamic group discovery via `files_group_by` templates (e.g. `stacks/{group}/**`)
- Deploy matrix JSON output for GitHub Actions `strategy.matrix`
- Workflow failure tracking with per-run or per-job granularity
- Concurrent workflow detection with deadlock-safe priority ordering
- Ancestor directory file association for monorepo layouts
- Static musl binaries for Linux (zero runtime dependencies)
## GitHub Action
```yaml
jobs:
detect:
runs-on: ubuntu-latest
outputs:
matrix: ${{ steps.changes.outputs.matrix }}
has_changes: ${{ steps.changes.outputs.has_changes }}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: lituus-io/le-change@v1
id: changes
with:
files: 'stacks/**/*.yaml'
files_group_by: 'stacks/{group}/**'
deploy:
needs: detect
if: needs.detect.outputs.has_changes == 'true'
strategy:
matrix: ${{ fromJson(needs.detect.outputs.matrix) }}
runs-on: ubuntu-latest
steps:
- run: echo "Deploying ${{ matrix.stack }}"
```
### Action Inputs
| Input | Default | Description |
|-------|---------|-------------|
| `files` | | Glob patterns to include (comma-separated) |
| `files_ignore` | | Glob patterns to exclude |
| `files_group_by` | | Group discovery template (e.g. `stacks/{group}/**`) |
| `files_group_by_key` | `name` | Group key mode: `name`, `path`, or `hash` |
| `files_ancestor_lookup_depth` | `0` | Ancestor directory lookup depth (max 3) |
| `track_workflow_failures` | `false` | Enable workflow failure tracking |
| `failure_tracking_level` | `run` | Tracking granularity: `run` or `job` |
| `wait_for_active_workflows` | `false` | Wait for concurrent overlapping workflows |
| `workflow_max_wait_seconds` | `300` | Max wait time in seconds |
| `workflow_name_filter` | | Glob pattern to filter workflow names |
| `deploy_matrix_include_reason` | `false` | Add action/reason to matrix entries |
| `deploy_matrix_include_concurrency` | `false` | Add concurrency info to matrix entries |
| `token` | `github.token` | GitHub token for API access |
| `base_sha` | | Override base commit SHA |
| `sha` | | Override head commit SHA |
### Action Outputs
| Output | Description |
|--------|-------------|
| `matrix` | Deploy matrix JSON for `fromJson()` |
| `has_changes` | `true` if any deployable changes detected |
| `any_changed` | `true` if any files changed |
| `changed_files` | Space-separated changed file paths |
| `changed_files_count` | Number of changed files |
| `added_files` | Space-separated added file paths |
| `modified_files` | Space-separated modified file paths |
| `deleted_files` | Space-separated deleted file paths |
| `deploy_decisions` | JSON array of per-group deploy decisions |
| `files_to_rebuild` | Files needing rebuild |
| `files_to_skip` | Files safe to skip |
| `diagnostics` | JSON array of diagnostic messages |
## CLI
```bash
lechange detect \
--files 'stacks/**/*.yaml' \
--files-group-by 'stacks/{group}/**' \
--base-sha abc123 \
--sha def456 \
--output-format json
```
All options accept environment variables with `LECHANGE_` prefix (e.g. `LECHANGE_FILES`).
Exit codes: `0` = changes detected, `1` = error, `2` = no changes.
## Python
```bash
pip install lechange
```
```python
from lechange import ChangeDetector, Config
detector = ChangeDetector(".")
config = Config(
files=["src/**/*.py"],
files_group_by="src/{group}/**",
base_sha="abc123",
sha="def456",
)
result = detector.get_changed_files(config)
print(result.all_changed_files)
print(result.deploy_matrix)
print(result.has_deployable_groups)
```
## Development
```bash
cargo test -p lechange-core # Core library tests
cargo test -p lechange-cli # CLI tests
cargo build --release -p lechange-cli # Release binary
```
## License
Copyright (c) 2024-2026 Lituus-io. All rights reserved.
AGPL-3.0-or-later. Commercial license available — contact spicyzhug@gmail.com.
| text/markdown; charset=UTF-8; variant=GFM | null | terekete <spicyzhug@gmail.com> | null | terekete <spicyzhug@gmail.com> | AGPL-3.0-or-later | git, diff, changed-files, performance, github-actions | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Rust",
"Topic :: Software Development :: Version Control",
"Topic :: Software Development :: Version Control :: Git",
"Typing :: Typed"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"pytest>=7.0; extra == \"dev\"",
"pytest-asyncio>=0.21; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"black>=23.0; extra == \"dev\"",
"mypy>=1.0; extra == \"dev\"",
"ruff>=0.1; extra == \"dev\""
] | [] | [] | [] | [
"Changelog, https://github.com/lituus-io/le-change/releases",
"Documentation, https://github.com/lituus-io/le-change#readme",
"Homepage, https://github.com/lituus-io/le-change",
"Issues, https://github.com/lituus-io/le-change/issues",
"Repository, https://github.com/lituus-io/le-change"
] | twine/6.2.0 CPython/3.12.12 | 2026-02-21T04:52:09.428224 | lechange-0.1.0-cp38-abi3-win_amd64.whl | 2,535,777 | e3/ce/36e78639a3d43e80cb4061ff5d352b158c81a7994cd2f767a6e24fa18907/lechange-0.1.0-cp38-abi3-win_amd64.whl | cp38 | bdist_wheel | null | false | 015d447d7822d00fb5bab2c24dfb0bea | 08c57515a80893703283d10c6241a520899bb0a21e895f4e618a084f8652e026 | e3ce36e78639a3d43e80cb4061ff5d352b158c81a7994cd2f767a6e24fa18907 | null | [
"LICENSE"
] | 179 |
2.4 | run-mcp-servers-with-aws-lambda | 0.5.9 | Run Model Context Protocol (MCP) servers with AWS Lambda | # Run Model Context Protocol (MCP) servers with AWS Lambda
[](https://pypi.org/project/run-mcp-servers-with-aws-lambda/)
[](https://www.npmjs.com/package/@aws/run-mcp-servers-with-aws-lambda)
This project enables you to run [Model Context Protocol](https://modelcontextprotocol.io) stdio-based servers in AWS Lambda functions.
Currently, most implementations of MCP servers and clients are entirely local on a single machine.
A desktop application such as an IDE or Claude Desktop initiates MCP servers locally as child processes
and communicates with each of those servers over a long-running stdio stream.
```mermaid
flowchart LR
subgraph "Your Laptop"
Host["Desktop Application<br>with MCP Clients"]
S1["MCP Server A<br>(child process)"]
S2["MCP Server B<br>(child process)"]
Host <-->|"MCP Protocol<br>(over stdio stream)"| S1
Host <-->|"MCP Protocol<br>(over stdio stream)"| S2
end
```
This library helps you to wrap existing stdio MCP servers into Lambda functions.
You can invoke these function-based MCP servers from your application using the MCP protocol
over short-lived HTTPS connections.
Your application can then be a desktop-based app, a distributed system running in the cloud,
or any other architecture.
```mermaid
flowchart LR
subgraph "Distributed System"
App["Your Application<br>with MCP Clients"]
S3["MCP Server A<br>(Lambda function)"]
S4["MCP Server B<br>(Lambda function)"]
App <-->|"MCP Protocol<br>(over HTTPS connection)"| S3
App <-->|"MCP Protocol<br>(over HTTPS connection)"| S4
end
```
Using this library, the Lambda function will manage the lifecycle of your stdio MCP server.
Each Lambda function invocation will:
1. Start the stdio MCP server as a child process
1. Initialize the MCP server
1. Forward the incoming request to the local server
1. Return the server's response to the function caller
1. Shut down the MCP server child process
This library supports connecting to Lambda-based MCP servers in four ways:
1. The [MCP Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http), using Amazon API Gateway. Typically authenticated using OAuth.
1. The MCP Streamable HTTP transport, using Amazon Bedrock AgentCore Gateway. Authenticated using OAuth.
1. A custom Streamable HTTP transport with support for SigV4, using a Lambda function URL. Authenticated with AWS IAM.
1. A custom Lambda invocation transport, using the Lambda Invoke API directly. Authenticated with AWS IAM.
## Determine your server parameters
Many stdio-based MCP servers's documentation encourages using tools that download and run the server on-demand.
For example, `uvx my-mcp-server` or `npx my-mcp-server`.
These tools are often not pre-packaged in the Lambda environment, and it can be inefficient to
re-download the server on every Lambda invocation.
Instead, the examples in this repository show how to package the MCP server along with
the Lambda function code, then start it with `python` or `node` (or `npx --offline`) directly.
You will need to determine the right parameters depending on your MCP server's package.
This can often be a trial and error process locally, since MCP server packaging varies.
<details>
<summary><b>Python server examples</b></summary>
Basic example:
```python
from mcp.client.stdio import StdioServerParameters
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
```
Locally, you would run this module using:
```bash
python -m my_mcp_server_python_module --my-server-command-line-parameter some_value
```
Other examples:
```bash
python -m mcpdoc.cli # Note the sub-module
python -c "from mcp_openapi_proxy import main; main()"
python -c "import asyncio; from postgres_mcp.server import main; asyncio.run(main())"
```
If you use Lambda layers, you need to also set the PYTHONPATH for the python sub-process:
```python
lambda_paths = ["/opt/python"] + sys.path
env_config = {"PYTHONPATH": ":".join(lambda_paths)}
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-c",
"from mcp_openapi_proxy import main; main()",
],
env=env_config,
)
```
</details>
<details>
<summary><b>Typescript server examples</b></summary>
Basic example:
```typescript
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
```
Locally, you would run this module using:
```bash
npx --offline my-mcp-server-typescript-module --my-server-command-line-parameter some_value
```
Other examples:
```bash
node /var/task/node_modules/@ivotoby/openapi-mcp-server/bin/mcp-server.js
```
</details>
## Use API Gateway
```mermaid
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
T2["API Gateway"]
T3["OAuth Server<br>(Cognito or similar)"]
App -->|"MCP Streamable<br>HTTP Transport"| T2
T2 -->|"Invoke"| T1
T2 -->|"Authorize"| T3
```
This solution is compatible with most MCP clients that support the streamable HTTP transport.
MCP servers deployed with this architecture can typically be used with off-the-shelf
MCP-compatible applications such as Cursor, Cline, Claude Desktop, etc.
You can choose your desired OAuth server provider for this solution. The examples in this
repository use Amazon Cognito, or you can use third-party providers such as Okta or Auth0
with API Gateway custom authorization.
<details>
<summary><b>Python server example</b></summary>
```python
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import APIGatewayProxyEventHandler, StdioServerAdapterRequestHandler
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
request_handler = StdioServerAdapterRequestHandler(server_params)
event_handler = APIGatewayProxyEventHandler(request_handler)
def handler(event, context):
return event_handler.handle(event, context)
```
See a full, deployable example [here](examples/servers/dad-jokes/).
</details>
<details>
<summary><b>Typescript server example</b></summary>
```typescript
import {
Handler,
Context,
APIGatewayProxyWithCognitoAuthorizerEvent,
APIGatewayProxyResult,
} from "aws-lambda";
import {
APIGatewayProxyEventHandler,
StdioServerAdapterRequestHandler,
} from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
const requestHandler = new APIGatewayProxyEventHandler(
new StdioServerAdapterRequestHandler(serverParams)
);
export const handler: Handler = async (
event: APIGatewayProxyWithCognitoAuthorizerEvent,
context: Context
): Promise<APIGatewayProxyResult> => {
return requestHandler.handle(event, context);
};
```
See a full, deployable example [here](examples/servers/dog-facts/).
</details>
<details>
<summary><b>Python client example</b></summary>
```python
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
# Create OAuth client provider here
async with streamablehttp_client(
url="https://abc123.execute-api.us-west-2.amazonaws.com/prod/mcp",
auth=oauth_client_provider,
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
```
See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/interactive_oauth.py).
</details>
<details>
<summary><b>Typescript client example</b></summary>
```typescript
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
// Create OAuth client provider here
const transport = new StreamableHTTPClientTransport(
"https://abc123.execute-api.us-west-2.amazonaws.com/prod/mcp",
{
authProvider: oauthProvider,
}
);
await client.connect(transport);
```
See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/interactive_oauth.ts).
</details>
## Use Bedrock AgentCore Gateway
```mermaid
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
T2["Bedrock AgentCore Gateway"]
T3["OAuth Server<br>(Cognito or similar)"]
App -->|"MCP Streamable<br>HTTP Transport"| T2
T2 -->|"Invoke"| T1
T2 -->|"Authorize"| T3
```
This solution is compatible with most MCP clients that support the streamable HTTP transport.
MCP servers deployed with this architecture can typically be used with off-the-shelf
MCP-compatible applications such as Cursor, Cline, Claude Desktop, etc.
You can choose your desired OAuth server provider with Bedrock AgentCore Gateway,
such as Amazon Cognito, Okta, or Auth0.
Using Bedrock AgentCore Gateway in front of your stdio-based MCP server requires that
you retrieve the MCP server's tool schema, and provide it in the
[AgentCore Gateway Lambda target configuration](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-add-target-lambda.html#gateway-building-lambda-multiple-tools).
AgentCore Gateway can then advertise the schema to HTTP clients and validate request inputs and outputs.
To retrieve and save your stdio-based MCP server's tool schema to a file, run:
```bash
npx @modelcontextprotocol/inspector --cli --method tools/list <your MCP server command and arguments> > tool-schema.json
# For example:
npx @modelcontextprotocol/inspector --cli --method tools/list uvx mcp-server-time > tool-schema.json
```
<details>
<summary><b>Python server example</b></summary>
```python
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import BedrockAgentCoreGatewayTargetHandler, StdioServerAdapterRequestHandler
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
request_handler = StdioServerAdapterRequestHandler(server_params)
event_handler = BedrockAgentCoreGatewayTargetHandler(request_handler)
def handler(event, context):
return event_handler.handle(event, context)
```
See a full, deployable example [here](examples/servers/book-search/).
</details>
<details>
<summary><b>Typescript server example</b></summary>
```typescript
import { Handler, Context } from "aws-lambda";
import {
BedrockAgentCoreGatewayTargetHandler,
StdioServerAdapterRequestHandler,
} from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
const requestHandler = new BedrockAgentCoreGatewayTargetHandler(
new StdioServerAdapterRequestHandler(serverParams)
);
export const handler: Handler = async (
event: Record<string, unknown>,
context: Context
): Promise<Record<string, unknown>> => {
return requestHandler.handle(event, context);
};
```
See a full, deployable example [here](examples/servers/dictionary/).
</details>
<details>
<summary><b>Python client example</b></summary>
```python
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
# Create OAuth client provider here
async with streamablehttp_client(
url="https://abc123.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp",
auth=oauth_client_provider,
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
```
See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/interactive_oauth.py).
</details>
<details>
<summary><b>Typescript client example</b></summary>
```typescript
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
// Create OAuth client provider here
const transport = new StreamableHTTPClientTransport(
"https://abc123.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp",
{
authProvider: oauthProvider,
}
);
await client.connect(transport);
```
See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/interactive_oauth.ts).
</details>
## Use a Lambda function URL
```mermaid
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
T2["Lambda function URL"]
App -->|"Custom Streamable HTTP<br>Transport with AWS Auth"| T2
T2 -->|"Invoke"| T1
```
This solution uses AWS IAM for authentication, and relies on granting
[Lambda InvokeFunctionUrl permission](https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html#urls-auth-iam) to your
IAM users and roles to enable access to the MCP server. Clients must use an extension to the MCP Streamable
HTTP transport that signs requests with [AWS SigV4](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html).
Off-the-shelf MCP-compatible applications are unlikely to have support for this custom transport,
so this solution is more appropriate for service-to-service communication rather than for end users.
<details>
<summary><b>Python server example</b></summary>
```python
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import LambdaFunctionURLEventHandler, StdioServerAdapterRequestHandler
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
request_handler = StdioServerAdapterRequestHandler(server_params)
event_handler = LambdaFunctionURLEventHandler(request_handler)
def handler(event, context):
return event_handler.handle(event, context)
```
See a full, deployable example [here](examples/servers/mcpdoc/).
</details>
<details>
<summary><b>Typescript server example</b></summary>
```typescript
import {
Handler,
Context,
APIGatewayProxyEventV2WithIAMAuthorizer,
APIGatewayProxyResultV2,
} from "aws-lambda";
import {
LambdaFunctionURLEventHandler,
StdioServerAdapterRequestHandler,
} from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
const requestHandler = new LambdaFunctionURLEventHandler(
new StdioServerAdapterRequestHandler(serverParams)
);
export const handler: Handler = async (
event: APIGatewayProxyEventV2WithIAMAuthorizer,
context: Context
): Promise<APIGatewayProxyResultV2> => {
return requestHandler.handle(event, context);
};
```
See a full, deployable example [here](examples/servers/cat-facts/).
</details>
<details>
<summary><b>Python client example</b></summary>
```python
from mcp import ClientSession
from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
async with aws_iam_streamablehttp_client(
endpoint="https://url-id-12345.lambda-url.us-west-2.on.aws",
aws_service="lambda",
aws_region="us-west-2",
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
```
See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/lambda_function_url.py).
</details>
<details>
<summary><b>Typescript client example</b></summary>
```typescript
import { StreamableHTTPClientWithSigV4Transport } from "@aws/run-mcp-servers-with-aws-lambda";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
const transport = new StreamableHTTPClientWithSigV4Transport(
new URL("https://url-id-12345.lambda-url.us-west-2.on.aws"),
{
service: "lambda",
region: "us-west-2",
}
);
await client.connect(transport);
```
See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/lambda_function_url.ts).
</details>
## Use the Lambda Invoke API
```mermaid
flowchart LR
App["MCP Client"]
T1["MCP Server<br>(Lambda function)"]
App -->|"Custom MCP Transport<br>(Lambda Invoke API)"| T1
```
Like the Lambda function URL approach, this solution uses AWS IAM for authentication.
It relies on granting
[Lambda InvokeFunction permission](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html)
to your IAM users and roles to enable access to the MCP server.
Clients must use a custom MCP transport that directly calls the
[Lambda Invoke API](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html).
Off-the-shelf MCP-compatible applications are unlikely to have support for this custom transport,
so this solution is more appropriate for service-to-service communication rather than for end users.
<details>
<summary><b>Python server example</b></summary>
```python
import sys
from mcp.client.stdio import StdioServerParameters
from mcp_lambda import stdio_server_adapter
server_params = StdioServerParameters(
command=sys.executable,
args=[
"-m",
"my_mcp_server_python_module",
"--my-server-command-line-parameter",
"some_value",
],
)
def handler(event, context):
return stdio_server_adapter(server_params, event, context)
```
See a full, deployable example [here](examples/servers/time/).
</details>
<details>
<summary><b>Typescript server example</b></summary>
```typescript
import { Handler, Context } from "aws-lambda";
import { stdioServerAdapter } from "@aws/run-mcp-servers-with-aws-lambda";
const serverParams = {
command: "npx",
args: [
"--offline",
"my-mcp-server-typescript-module",
"--my-server-command-line-parameter",
"some_value",
],
};
export const handler: Handler = async (event, context: Context) => {
return await stdioServerAdapter(serverParams, event, context);
};
```
See a full, deployable example [here](examples/servers/weather-alerts/).
</details>
<details>
<summary><b>Python client example</b></summary>
```python
from mcp import ClientSession
from mcp_lambda import LambdaFunctionParameters, lambda_function_client
server_params = LambdaFunctionParameters(
function_name="my-mcp-server-function",
region_name="us-west-2",
)
async with lambda_function_client(server_params) as (
read_stream,
write_stream,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tool_result = await session.call_tool("echo", {"message": "hello"})
```
See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/lambda_function.py).
</details>
<details>
<summary><b>Typescript client example</b></summary>
```typescript
import {
LambdaFunctionParameters,
LambdaFunctionClientTransport,
} from "@aws/run-mcp-servers-with-aws-lambda";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
const serverParams: LambdaFunctionParameters = {
functionName: "my-mcp-server-function",
regionName: "us-west-2",
};
const client = new Client(
{
name: "my-client",
version: "0.0.1",
},
{
capabilities: {
sampling: {},
},
}
);
const transport = new LambdaFunctionClientTransport(serverParams);
await client.connect(transport);
```
See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/lambda_function.ts).
</details>
## Related projects
- To write custom MCP servers in Lambda functions,
see the [MCP Lambda Handler](https://github.com/awslabs/mcp/tree/main/src/mcp-lambda-handler) project.
- To invoke existing Lambda functions as tools through a stdio MCP server,
see the [AWS Lambda Tool MCP Server](https://awslabs.github.io/mcp/servers/lambda-tool-mcp-server/) project.
## Considerations
- This library currently supports MCP servers and clients written in Python and Typescript.
Other languages such as Kotlin are not supported.
- This library only adapts stdio MCP servers for Lambda, not servers written for other protocols such as SSE.
- This library does not maintain any MCP server state or sessions across Lambda function invocations.
Only stateless MCP servers are a good fit for using this library. For example, MCP servers
that invoke stateless tools like the [time MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/time)
or make stateless web requests like the [fetch MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch).
Stateful MCP servers are not a good fit, because they will lose their state on every request.
For example, MCP servers that manage data on disk or in memory such as
the [sqlite MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite),
the [filesystem MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem),
and the [git MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/git).
- This library does not provide mechanisms for managing any secrets needed by the wrapped
MCP server. For example, the [GitHub MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/github)
and the [Brave search MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search)
require API keys to make requests to third-party APIs.
You may configure these API keys as
[encrypted environment variables](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars-encryption.html)
in the Lambda function's configuration. However, note that anyone with access to invoke the Lambda function
will then have access to use your API key to call the third-party APIs by invoking the function.
We recommend limiting access to the Lambda function using
[least-privilege IAM policies](https://docs.aws.amazon.com/lambda/latest/dg/security-iam.html).
If you use an identity-based authentication mechanism such as OAuth, you could also store and retrieve API keys per user but there are no implementation examples in this repository.
## Deploy and run the examples
See the [development guide](DEVELOP.md) for instructions to deploy and run the examples in this repository.
## Security
See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.
## License
This project is licensed under the Apache-2.0 License.
| text/markdown | Amazon Web Services | null | null | null | Apache License (2.0) | aws, lambda, mcp, modelcontextprotocol | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"aiobotocore>=2.26.0",
"anyio>=4.12.0",
"aws-lambda-powertools>=3.22.0",
"mcp-proxy-for-aws>=1.1.2",
"mcp>=1.23.1",
"types-aiobotocore[lambda]>=2.26.0; extra == \"stubs\""
] | [] | [] | [] | [
"Repository, https://github.com/awslabs/run-model-context-protocol-servers-with-aws-lambda",
"Issues, https://github.com/awslabs/run-model-context-protocol-servers-with-aws-lambda/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:52:09.317662 | run_mcp_servers_with_aws_lambda-0.5.9.tar.gz | 154,184 | 28/a6/41754699c0f40ec0cf24b82757b1408d49a998322393e408265e8e82118d/run_mcp_servers_with_aws_lambda-0.5.9.tar.gz | source | sdist | null | false | cb7810222679a38903d910cc0860fef0 | e7f3117cbebb63839d8b58f0f255bc45f3a0abc994dca5f09040bcee1d075ea1 | 28a641754699c0f40ec0cf24b82757b1408d49a998322393e408265e8e82118d | null | [] | 221 |
2.4 | omendb | 0.0.29 | Fast embedded vector database with HNSW + ACORN-1 filtered search | # OmenDB
[](https://pypi.org/project/omendb/)
[](https://www.npmjs.com/package/omendb)
[](https://github.com/omendb/omendb/blob/main/LICENSE)
Embedded vector database for Python and Node.js. No server, no setup, just install.
- **7,600 QPS** single / **64,000 QPS** batch search, 99.8% recall (SIFT-100K)
- **60K vec/s** insert throughput
- **SQ8 quantization** (4x compression, 99.8% recall, 2x faster search)
- **ACORN-1** predicate-aware filtered search
- **Hybrid search** -- BM25 text + vector with RRF fusion
- **Multi-vector** -- ColBERT/MaxSim with MUVERA and token pooling
- **Auto-embedding** -- pass a function, store documents, search with strings
```bash
pip install omendb # Python
npm install omendb # Node.js
```
## Quick Start
### Python
**With auto-embedding** -- pass an embedding function, work with documents and strings:
```python
import omendb
def embed(texts):
# Your embedding model here (OpenAI, sentence-transformers, etc.)
return [[0.1] * 384 for _ in texts]
db = omendb.open("./mydb", dimensions=384, embedding_fn=embed)
# Add documents -- auto-embedded
db.set([
{"id": "doc1", "document": "Paris is the capital of France", "metadata": {"topic": "geography"}},
{"id": "doc2", "document": "The mitochondria is the powerhouse of the cell", "metadata": {"topic": "biology"}},
])
# Search with text -- auto-embedded
results = db.search("capital of France", k=5)
```
**With vectors** -- bring your own embeddings:
```python
db = omendb.open("./mydb", dimensions=128)
db.set([
{"id": "doc1", "vector": [0.1] * 128, "metadata": {"category": "science"}},
{"id": "doc2", "vector": [0.2] * 128, "metadata": {"category": "history"}},
])
results = db.search([0.1] * 128, k=5)
results = db.search([0.1] * 128, k=5, filter={"category": "science"})
```
### Node.js
**With auto-embedding:**
```javascript
const { open } = require("omendb");
const db = open("./mydb", { dimensions: 384 }, embed);
await db.set([{ id: "doc1", document: "Paris is the capital of France" }]);
const results = await db.search("capital of France", 5);
```
**With vectors:**
```javascript
const db = open("./mydb", { dimensions: 128 });
await db.set([{ id: "doc1", vector: new Float32Array(128).fill(0.1) }]);
const results = await db.search(new Float32Array(128).fill(0.1), 5);
```
## Features
- **HNSW graph indexing** -- SIMD-accelerated distance computation
- **ACORN-1 filtered search** -- predicate-aware graph traversal, 37.79x speedup over post-filtering
- **SQ8 quantization** -- 4x compression, 99.8% recall, 2x faster search
- **BM25 text search** -- full-text search via Tantivy
- **Hybrid search** -- RRF fusion of vector + text results
- **Multi-vector / ColBERT** -- MUVERA + MaxSim scoring for token-level retrieval
- **Token pooling** -- k-means clustering, 50% storage reduction for multi-vector
- **Auto-embedding** -- `embedding_fn` (Python) / `embeddingFn` (Node.js) for document-in, text-query workflows
- **Collections** -- namespaced sub-databases within a single file
- **Persistence** -- WAL + atomic checkpoints
- **O(1) lazy delete + compaction** -- deleted records cleaned up in background
- **Segment-based architecture** -- background merging for sustained write throughput
- **Context manager** (Python) / `close()` (Node.js) for resource cleanup
## Platforms
| Platform | Status |
| ---------------------------- | --------- |
| Linux (x86_64, ARM64) | Supported |
| macOS (Intel, Apple Silicon) | Supported |
## API Reference
### Python
```python
# Database
db = omendb.open(path, dimensions, embedding_fn=fn) # With auto-embedding
db = omendb.open(path, dimensions) # Manual vectors
db = omendb.open(":memory:", dimensions) # In-memory
# CRUD
db.set(items) # Insert/update (vectors or documents)
db.set("id", vector, metadata) # Single insert
db.get(id) # Get by ID
db.get_batch(ids) # Batch get
db.delete(ids) # Delete by IDs
db.delete_by_filter(filter) # Delete by metadata filter
db.update(id, vector, metadata, text) # Update fields
# Search
db.search(query, k) # Vector or string query
db.search(query, k, filter={...}) # Filtered search (ACORN-1)
db.search(query, k, max_distance=0.5) # Distance threshold
db.search_batch(queries, k) # Batch search (parallel)
# Hybrid search
db.search_hybrid(query_vector, query_text, k)
db.search_hybrid("query text", k=10) # String query (auto-embeds both)
db.search_text(query_text, k) # Text-only BM25
# Iteration
len(db) # Count
db.count(filter={...}) # Filtered count
db.ids() # Lazy ID iterator
db.items() # All items (loads to memory)
for item in db: ... # Lazy iteration
"id" in db # Existence check
# Collections
col = db.collection("users") # Create/get collection
db.collections() # List collections
db.delete_collection("users") # Delete collection
# Persistence
db.flush() # Flush to disk
db.close() # Close
db.compact() # Remove deleted records
db.optimize() # Reorder for cache locality
db.merge_from(other_db) # Merge databases
# Config
db.ef_search # Get search quality
db.ef_search = 200 # Set search quality
db.dimensions # Vector dimensionality
db.stats() # Database statistics
```
### Node.js
```javascript
// Database
const db = open(path, { dimensions, embeddingFn: fn });
const db = open(path, { dimensions });
// CRUD
await db.set(items);
db.get(id);
db.getBatch(ids);
db.delete(ids);
db.deleteByFilter(filter);
await db.set([{ id, vector, metadata }]); // update
// Search
await db.search(query, k);
await db.search(query, k, { filter, maxDistance, ef });
await db.searchBatch(queries, k);
// Hybrid
await db.searchHybrid(queryVector, queryText, k);
db.searchText(queryText, k);
// Collections
db.collection("users");
db.collections();
db.deleteCollection("users");
// Persistence
db.flush();
db.close();
db.compact();
db.optimize();
```
## Configuration
```python
db = omendb.open(
"./mydb", # Creates ./mydb.omen + ./mydb.wal
dimensions=384,
m=16, # HNSW connections per node (default: 16)
ef_construction=200, # Index build quality (default: 100)
ef_search=100, # Search quality (default: 100)
quantization=True, # SQ8 quantization (default: None)
metric="cosine", # Distance metric (default: "l2")
embedding_fn=embed, # Auto-embed documents and string queries
)
# Quantization options:
# - True or "sq8": SQ8 ~4x smaller, ~99% recall (recommended)
# - None/False: Full precision (default)
# Distance metric options:
# - "l2" or "euclidean": Euclidean distance (default)
# - "cosine": Cosine distance (1 - cosine similarity)
# - "dot" or "ip": Inner product (for MIPS)
# Context manager (auto-flush on exit)
with omendb.open("./db", dimensions=768) as db:
db.set([...])
```
## Distance Filtering
Use `max_distance` to filter out low-relevance results (prevents "context rot" in RAG):
```python
# Only return results with distance <= 0.5
results = db.search(query, k=10, max_distance=0.5)
# Combine with metadata filter
results = db.search(query, k=10, filter={"type": "doc"}, max_distance=0.5)
```
This ensures your RAG pipeline only receives highly relevant context, avoiding distractors that can hurt LLM performance.
## Filters
```python
# Equality
{"field": "value"} # Shorthand
{"field": {"$eq": "value"}} # Explicit
# Comparison
{"field": {"$ne": "value"}} # Not equal
{"field": {"$gt": 10}} # Greater than
{"field": {"$gte": 10}} # Greater or equal
{"field": {"$lt": 10}} # Less than
{"field": {"$lte": 10}} # Less or equal
# Membership
{"field": {"$in": ["a", "b"]}} # In list
{"field": {"$contains": "sub"}} # String contains
# Logical
{"$and": [{...}, {...}]} # AND
{"$or": [{...}, {...}]} # OR
```
## Hybrid Search
Combine vector similarity with BM25 full-text search using RRF fusion:
```python
# With embedding_fn -- pass a string for both vector and text query
db = omendb.open("./mydb", dimensions=384, embedding_fn=embed)
db.set([
{"id": "doc1", "document": "Paris is the capital of France", "metadata": {"topic": "geography"}},
])
results = db.search_hybrid("capital of France", k=10)
# With manual vectors
db.search_hybrid(query_vector, "query text", k=10)
# Tune alpha: 0 = text only, 1 = vector only, default = 0.5
db.search_hybrid(query_vector, "query text", k=10, alpha=0.7)
# Get separate keyword and semantic scores for debugging/tuning
results = db.search_hybrid(query_vector, "query text", k=10, subscores=True)
# Returns: {"id": "...", "score": 0.85, "keyword_score": 0.92, "semantic_score": 0.78}
# Text-only BM25
db.search_text("capital of France", k=10)
```
## Multi-vector (ColBERT)
MUVERA with MaxSim scoring for ColBERT-style token-level retrieval. Token pooling via k-means reduces storage by 50%.
```python
mvdb = omendb.open(":memory:", dimensions=128, multi_vector=True)
mvdb.set([{
"id": "doc1",
"vectors": [[0.1]*128, [0.2]*128, [0.3]*128], # Token embeddings
}])
results = mvdb.search([[0.1]*128, [0.15]*128], k=5) # MaxSim scoring
```
## Performance
SIFT-100K · 128D · M=16 · ef_construction=100 · ef_search=100 · k=10 · Apple M3 Max
| Mode | Build | Single | Batch | Recall@10 |
| ---- | ---------- | ---------- | ---------- | --------- |
| fp32 | 59,789 v/s | 7,644 QPS | 64,570 QPS | 99.8% |
| SQ8 | 59,905 v/s | 15,403 QPS | 95,442 QPS | 99.8% |
Batch search uses Rayon for parallel execution across all cores. Scales to 1M+ vectors.
**Filtered search** (ACORN-1, 10% selectivity): predicate-aware graph traversal, no post-filter overhead.
<details>
<summary>Benchmark methodology</summary>
- **Dataset**: SIFT-100K (real 128D embeddings, not random vectors)
- **Parameters**: M=16, ef_construction=100, ef_search=100, k=10
- **Batch**: parallel via Rayon
- **Recall**: validated against brute-force ground truth
- **Reproduce**: `cd python && uv run python benchmark.py`
</details>
## Tuning
The `ef_search` parameter controls the recall/speed tradeoff at query time. Higher values explore more candidates, improving recall but slowing search.
**Rules of thumb:**
- `ef_search` must be >= k (number of results requested)
- For 128D embeddings: ef=100 usually achieves 90%+ recall
- For 768D+ embeddings: increase to ef=200-400 for better recall
- If recall drops at scale (50K+), increase both ef_search and ef_construction
**Runtime tuning:**
```python
# Check current value
print(db.ef_search) # 100
# Increase for better recall (slower)
db.ef_search = 200
# Decrease for speed (may reduce recall)
db.ef_search = 50
# Per-query override
results = db.search(query, k=10, ef=300)
```
**Recommended settings by use case:**
| Use Case | ef_search | Expected Recall |
| ------------------- | --------- | --------------- |
| Fast search (128D) | 64 | ~85% |
| Balanced (default) | 100 | ~90% |
| High recall (768D+) | 200-300 | ~95%+ |
| Maximum recall | 500+ | ~98%+ |
## Examples
See complete working examples:
- [`python/examples/quickstart.py`](python/examples/quickstart.py) -- Minimal Python example
- [`python/examples/basic.py`](python/examples/basic.py) -- CRUD operations and persistence
- [`python/examples/filters.py`](python/examples/filters.py) -- All filter operators
- [`python/examples/rag.py`](python/examples/rag.py) -- RAG workflow with mock embeddings
- [`python/examples/embedding_fn.py`](python/examples/embedding_fn.py) -- Auto-embedding with embedding_fn
- [`python/examples/quantization.py`](python/examples/quantization.py) -- SQ8 quantization
- [`node/examples/quickstart.js`](node/examples/quickstart.js) -- Minimal Node.js example
- [`node/examples/embedding_fn.js`](node/examples/embedding_fn.js) -- Auto-embedding with embeddingFn
- [`node/examples/multivector.ts`](node/examples/multivector.ts) -- Multi-vector / ColBERT
## Integrations
### LangChain
```bash
pip install omendb[langchain]
```
```python
from langchain_openai import OpenAIEmbeddings
from omendb.langchain import OmenDBVectorStore
store = OmenDBVectorStore.from_texts(
texts=["Paris is the capital of France"],
embedding=OpenAIEmbeddings(),
path="./langchain_vectors",
)
docs = store.similarity_search("capital of France", k=1)
```
### LlamaIndex
```bash
pip install omendb[llamaindex]
```
```python
from llama_index.core import VectorStoreIndex, Document, StorageContext
from omendb.llamaindex import OmenDBVectorStore
vector_store = OmenDBVectorStore(path="./llama_vectors")
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(
[Document(text="OmenDB is fast")],
storage_context=storage_context,
)
response = index.as_query_engine().query("What is OmenDB?")
```
## License
[Elastic License 2.0](LICENSE) -- Free to use, modify, and embed. The only restriction: you can't offer OmenDB as a managed service to third parties.
| text/markdown; charset=UTF-8; variant=GFM | OmenDB Team | null | null | null | Elastic-2.0 | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: Other/Proprietary License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Rust"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"numpy>=1.24.4",
"langchain-core>=0.2.0; extra == \"langchain\"",
"llama-index-core>=0.10.0; extra == \"llamaindex\""
] | [] | [] | [] | [
"Homepage, https://github.com/omendb/omendb",
"Repository, https://github.com/omendb/omendb"
] | maturin/1.12.3 | 2026-02-21T04:50:42.160587 | omendb-0.0.29.tar.gz | 704,252 | e7/eb/cc861de2f292a61de00495da706cefa286da7978faf966b24c6b7d954435/omendb-0.0.29.tar.gz | source | sdist | null | false | ccd085f76496dd0d462049c8782ae25a | 7d117cf7101ad8125db7786d86ce708f32de6bd87acc7192e51594eac1d2ec70 | e7ebcc861de2f292a61de00495da706cefa286da7978faf966b24c6b7d954435 | null | [] | 1,702 |
2.4 | tmmc-lnpy | 0.8.1.dev0 | Analysis of lnPi results from TMMC simulation | <!-- markdownlint-disable MD041 -->
<!-- prettier-ignore-start -->
[![Repo][repo-badge]][repo-link]
[![Docs][docs-badge]][docs-link]
[![PyPI license][license-badge]][license-link]
[![PyPI version][pypi-badge]][pypi-link]
[![Conda (channel only)][conda-badge]][conda-link]
[![Code style: ruff][ruff-badge]][ruff-link]
[![uv][uv-badge]][uv-link]
<!--
For more badges, see
https://shields.io/category/other
https://naereen.github.io/badges/
[pypi-badge]: https://badge.fury.io/py/tmmc-lnpy
-->
[ruff-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
[ruff-link]: https://github.com/astral-sh/ruff
[uv-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json
[uv-link]: https://github.com/astral-sh/uv
[pypi-badge]: https://img.shields.io/pypi/v/tmmc-lnpy
[pypi-link]: https://pypi.org/project/tmmc-lnpy
[docs-badge]: https://img.shields.io/badge/docs-sphinx-informational
[docs-link]: https://pages.nist.gov/tmmc-lnpy/
[repo-badge]: https://img.shields.io/badge/--181717?logo=github&logoColor=ffffff
[repo-link]: https://github.com/usnistgov/tmmc-lnpy
[conda-badge]: https://img.shields.io/conda/v/conda-forge/tmmc-lnpy
[conda-link]: https://anaconda.org/conda-forge/tmmc-lnpy
[license-badge]: https://img.shields.io/pypi/l/tmmc-lnpy?color=informational
[license-link]: https://github.com/usnistgov/tmmc-lnpy/blob/main/LICENSE
[changelog-link]: https://github.com/usnistgov/tmmc-lnpy/blob/main/CHANGELOG.md
<!-- other links -->
<!-- prettier-ignore-end -->
# `tmmc-lnpy`
## Overview
A package to analyze $\ln \Pi(N)$ data from Transition Matrix Monte Carlo
simulation. The main output from TMMC simulations, $\ln \Pi(N)$, provides a
means to calculate a host of thermodynamic properties. Moreover, if $\ln \Pi(N)$
is calculated at a specific chemical potential, it can be reweighted to provide
thermodynamic information at a different chemical potential
## Features
`tmmc-lnpy` provides a wide array of routines to analyze $\ln \Pi(N)$. These
include:
- Reweighting to arbitrary chemical potential
- Segmenting $\ln \Pi(N)$ (to identify unique phases)
- Containers for interacting with several values of $\ln \Pi(N)$ in a vectorized
way.
- Calculating thermodynamic properties from these containers
- Calculating limits of stability, and phase equilibrium
## Status
This package is actively used by the author. Please feel free to create a pull
request for wanted features and suggestions!
## Example usage
Note that the distribution name `tmmc-lnpy` is different than the import name
`lnpy` due to name clashing on pypi.
```pycon
>>> import numpy as np
>>> import lnpy
>>> import lnpy.examples
>>> ref = lnpy.examples.load_example_lnpimasked("lj_sub")
>>> phase_creator = lnpy.PhaseCreator(nmax=1, ref=ref)
>>> build_phases = phase_creator.build_phases_mu([None])
>>> collection = lnpy.lnPiCollection.from_builder(
... lnzs=np.linspace(-10, 3, 5), build_phases=build_phases
... )
# Collections are like pandas.Series
>>> collection
<class lnPiCollection>
lnz_0 phase
-10.00 0 [-10.0]
-6.75 0 [-6.75]
-3.50 0 [-3.5]
-0.25 0 [-0.25]
3.00 0 [3.0]
dtype: object
# Access xarray backend for Grand Canonical properties with `xge` accessor
>>> collection.xge.betaOmega()
<xarray.DataArray 'betaOmega' (lnz_0: 5, phase: 1)> Size: 40B
array([[-2.3245e-02],
[-6.0370e-01],
[-1.8552e+02],
[-1.5447e+03],
[-2.9580e+03]])
Coordinates:
* lnz_0 (lnz_0) float64 40B -10.0 -6.75 -3.5 -0.25 3.0
* phase (phase) int64 8B 0
beta float64 8B 1.372
volume float64 8B 512.0
Attributes:
dims_n: ['n_0']
dims_lnz: ['lnz_0']
dims_comp: ['component']
dims_state: ['lnz_0', 'beta', 'volume']
dims_rec: ['sample']
standard_name: grand_potential
long_name: $\beta \Omega(\mu,V,T)$
```
<!-- end-docs -->
## Installation
<!-- start-installation -->
Use one of the following
```bash
pip install tmmc-lnpy
```
or
```bash
conda install -c conda-forge tmmc-lnpy
```
<!-- end-installation -->
## Documentation
See the [documentation][docs-link] for a look at `tmmc-lnpy` in action.
## What's new?
See [changelog][changelog-link].
## License
This is free software. See [LICENSE][license-link].
## Related work
This package is used for with
[thermoextrap](https://github.com/usnistgov/thermo-extrap) to analyze
thermodynamically extrapolated macro state probability distributions.
## Contact
The author can be reached at <wpk@nist.gov>.
## Credits
This package was created using
[Cookiecutter](https://github.com/audreyr/cookiecutter) with the
[usnistgov/cookiecutter-nist-python](https://github.com/usnistgov/cookiecutter-nist-python)
template.
| text/markdown | William P. Krekelberg | William P. Krekelberg <wpk@nist.gov> | null | null | null | tmmc-lnpy | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Science/Research",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Scientific/Engineering"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"bottleneck",
"importlib-resources; python_full_version < \"3.10\"",
"joblib",
"lazy-loader",
"module-utilities>=0.9.0",
"numba<0.63,>=0.58; python_full_version < \"3.14\" and platform_machine == \"x86_64\" and sys_platform == \"darwin\"",
"numba>=0.58; (python_full_version < \"3.14\" and sys_platform != \"darwin\") or platform_machine != \"x86_64\"",
"numba>=0.63; python_full_version >= \"3.14\"",
"numpy",
"pandas>=2.3.0",
"pooch",
"scikit-image>=0.21",
"scipy",
"tqdm",
"typing-extensions>=4.10.0; python_full_version < \"3.13\"",
"xarray",
"tmmc-lnpy[resample,viz]; extra == \"all\"",
"cmomy>=1.0.3; extra == \"resample\"",
"dask[diagnostics]; extra == \"resample\"",
"netcdf4; extra == \"resample\"",
"ipywidgets; extra == \"viz\"",
"matplotlib; extra == \"viz\""
] | [] | [] | [] | [
"Documentation, https://pages.nist.gov/tmmc-lnpy/",
"Homepage, https://github.com/usnistgov/tmmc-lnpy"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:49:31.781644 | tmmc_lnpy-0.8.1.dev0.tar.gz | 120,287 | ae/4c/d41d86ada4853ff0c97c36212ee85cae135a5919c232af088e25fa1fefbc/tmmc_lnpy-0.8.1.dev0.tar.gz | source | sdist | null | false | cb9f4c1e5f80bc0045c05ee13bf3f397 | 94f7f0aa530d14a0d9462ddd8725234d80459d94403b33974c9789305c8fbe10 | ae4cd41d86ada4853ff0c97c36212ee85cae135a5919c232af088e25fa1fefbc | NIST-PD | [
"LICENSE"
] | 201 |
2.4 | theow | 0.0.9 | LLM-in-the-loop rule based expert system | <div align="center">
# theow
*þēow - Old English for "servant" or "bondman."*
</div>
---
Theow is a [rule engine](https://www.geeksforgeeks.org/artificial-intelligence/rule-based-system-in-ai/) designed for auto-failover. It captures failure context automatically, semantically matches it against existing rules, and executes bound actions for recovery. Rules are deterministic. Same context, same fix, every time.
When no rule matches, Theow's internal agent uses an LLM to investigate and write a new rule. This agent is leashed and programmatic by design. It restricts the LLM to a defined set of tools. You specify what the LLM can do, nothing more, providing full but secure automation. As rules accumulate, LLM calls decrease. Since failure modes are finite, they may reach zero over time.
## TL;DR
- **Mark functions** for recovery with `@theow.mark()` - failures trigger the rule engine
- **Rules match context** and execute deterministic fixes
- **No match?** LLM explores, writes a new rule, rule handles it next time
- **You define the tools** the LLM can use - nothing more, nothing less
- **Rules accumulate**, LLM calls decrease, may hit zero over time
## Example
A simplified pipeline with Theow-managed failure recovery:
```python
from theow import Theow
pipeline_agent = Theow(
theow_dir="./.theow",
name="pipeline",
llm="gemini/gemini-2.0-flash",
)
@pipeline_agent.mark(
context_from=lambda task, exc: {
"stage": "process",
"task_id": task.id,
"error": str(exc),
},
explorable=True,
)
def process(task):
# do work that might fail
...
def run_pipeline(task):
prepare(task)
process(task) # failures here trigger theow
post_process(task)
complete(task)
```
When `process()` fails, Theow captures the context, matches it against rules, and attempts recovery. If no rule exists and exploration is enabled, the LLM investigates and writes one. This pattern extrapolates to any pipeline with a sequential flow.
## Components
### Initialization
```python
from theow import Theow
pipeline_agent = Theow(
theow_dir="./.theow", # rules, actions, vector store
name="pipeline", # for logging
llm="gemini/gemini-2.0-flash", # primary LLM (provider/model)
llm_secondary="anthropic/claude-sonnet-4-20250514", # fallback LLM
session_limit=20, # max explorations per session
max_tool_calls_per_session=30, # max tool calls per session
max_tokens_per_session=8192, # max tokens per session
)
```
Initialization creates the theow directory structure, loads existing rules and actions, and sets up the vector store. The `name` parameter identifies this instance in logs, making it easy to trace which agent handled which failure in a multi-agent setup.
```
.theow/
├── rules/ # Rule YAML files
├── actions/ # Action Python files
├── prompts/ # Prompt templates
└── chroma/ # Vector DB (auto-managed)
```
### Marker
The `@mark` decorator wraps functions for automatic recovery. When the function raises an exception, Theow captures context, matches against rules, and attempts recovery.
```python
@pipeline_agent.mark(
context_from=lambda task, exc: { # (args, exception) -> dict
"stage": "process",
"error": str(exc),
"task_id": task.id,
},
max_retries=3, # max rules to try
rules=["specific_rule"], # try these first, by name
tags=["pipeline"], # then try rules with these tags
fallback=True, # fall back to vector search
explorable=True, # allow LLM exploration
collection="pipeline", # chroma collection for indexing
)
def process(task):
...
```
Theow adds tracebacks automatically. The `context_from` callable builds the context dict that rules match against. Include whatever information is relevant for diagnosing failures: error messages, identifiers, state. This dict can be extended with any keys your rules need.
### Lifecycle Hooks
The `@mark` decorator accepts optional `setup` and `teardown` hooks that run around each recovery attempt. These let you prepare the environment before recovery and clean up or react after it, without coupling that logic into your rules or actions.
Hooks do **not** run on the initial function call - only when recovery is triggered.
```python
def my_setup(state: dict, attempt: int) -> dict | None:
"""Runs before each recovery attempt.
Args:
state: Dict pre-populated with the marked function's arguments.
Persists across attempts - use it to carry data between hooks.
attempt: Current attempt number (1-indexed).
Returns:
The (optionally modified) state dict back, or None to keep it as-is.
Raise an exception to abort recovery entirely.
"""
state["backup"] = snapshot(state["workspace"])
return state
def my_teardown(state: dict, attempt: int, success: bool) -> None:
"""Runs after each recovery attempt.
Args:
state: Same dict from setup, carrying any data you stored.
attempt: Current attempt number.
success: True if the retried function succeeded, False otherwise.
"""
if not success:
restore(state["backup"])
@pipeline_agent.mark(
context_from=lambda workspace, exc: {"error": str(exc)},
setup=my_setup,
teardown=my_teardown,
)
def process(workspace):
...
```
**Lifecycle per attempt:**
```mermaid
sequenceDiagram
participant C as Consumer
participant M as @mark
participant S as setup()
participant R as Rule Engine
participant F as fn()
participant T as teardown()
C->>M: call fn()
M->>F: try fn()
F-->>M: exception
loop each retry attempt
M->>S: setup(state, attempt)
S-->>M: ok / raise to abort
M->>R: find rule + run action
R-->>M: applied / not found
M->>F: retry fn()
F-->>M: success / failure
M->>T: teardown(state, attempt, success)
end
M-->>C: return result or re-raise
```
**Hook state** is automatically pre-populated with the marked function's named arguments (via `inspect.signature`). In the example above, `state["workspace"]` is available without manual wiring. You can add your own keys - the dict persists across all attempts within a single recovery cycle.
**Use cases:**
- **Workspace stashing**: Snapshot state before recovery, restore on failure, keep on success. This protects the working environment from partial or broken fixes.
- **External resource management**: Acquire locks, create temp directories, or spin up services before recovery, and release them after regardless of outcome.
- **Metrics and observability**: Track attempt timings, log recovery outcomes, or emit metrics per attempt without polluting action logic.
- **Conditional abort**: A `setup` hook that raises aborts the entire recovery loop. Useful for circuit-breaking (e.g., skip recovery if the same failure has been seen too many times recently).
**Behavior:**
- `setup` raising an exception aborts recovery - the original exception is re-raised.
- `teardown` errors are logged but never propagated - they cannot break recovery or the consumer pipeline.
- If no hooks are provided, recovery works exactly as before. Hooks are fully optional.
### Rules
Rules are YAML files in `.theow/rules/` that define conditions and responses. The `when` block matches against the context dict populated by `context_from` in the [marker](#marker).
```yaml
name: config_missing # unique identifier
description: Required config file not found # used for vector search
tags: [config, setup] # for filtering
when: # all facts must match
- fact: error
contains: "FileNotFoundError" # substring match
- fact: error
regex: 'config/(?P<filename>\w+\.yaml)' # regex with named captures
examples: # improves vector search recall
- "FileNotFoundError: config/database.yaml not found"
then: # actions to execute
- action: create_default_config
params:
filename: "{filename}" # captured from regex
```
Fact operators: `equals` (exact), `contains` (substring), `regex` (with named captures). Multiple actions can be chained in the `then` block and run sequentially.
### Rule Engine
The engine does not brute-force match facts against all available rules. Instead, it uses semantic search to find rules similar to the failure context, then validates facts against those candidates. This keeps matching fast as the rule set grows.
**1. Explicit Filtering**
If the `@mark` decorator specifies `rules=["name"]` or `tags=["tag"]`, the engine filters the rule set to only those rules. Rules specified by name are tried first, then rules matching the tags. Each candidate rule's `when` block is validated against the context. If a rule matches, its actions are executed and the engine stops. This allows you to scope recovery to known, trusted rules for specific failure points.
**2. Semantic Search**
When no explicit match is found, the engine uses vector search via ChromaDB:
1. **Metadata pre-filter**: Facts with `equals` constraints filter candidates to rules where exact-match facts align with the context
2. **Vector similarity**: Rule descriptions and examples are embedded and searched against the error context. This lets the engine apply existing solutions to similar known problems, even if the exact error message differs
3. **Fact validation**: All `when` conditions must match. Similarity alone is not enough to trigger an action. The engine enforces that facts match to avoid running fixes for the wrong problem
**3. Execution**
The engine retrieves up to N candidates (N = `max_retries`) and tries each in order. If an action fails, the next candidate is tried.
### Actions
Actions are Python functions that rules execute. When a rule matches, its `then` block specifies which actions to run. Parameters come from regex captures in the rule or from the context built by `context_from` in the [marker](#marker).
Actions live in `.theow/actions/` and are auto-discovered on startup.
```python
from theow import action
@action("create_default_config")
def create_default_config(filename: str) -> dict:
"""Create a default config file."""
Path(f"config/{filename}").write_text("# default\n")
return {"status": "ok", "created": filename}
```
The action name in the decorator must match the action referenced in the rule's `then` block.
### Exploration
When no rule matches and `explorable=True` in the marker, Theow brings in the LLM. The configured LLM receives the failure context (traceback, exception, and everything from `context_from`) and investigates using the registered [tools](#tools).
Exploration requires the `THEOW_EXPLORE` environment variable to be set. This lets you programmatically enable or disable LLM exploration without changing code. Useful for running with exploration in dev/CI but disabling it in production where you only want deterministic rule matching.
```bash
THEOW_EXPLORE=1 python my_script.py
```
**Semantic Rule Search**
The LLM has access to an internal `search_rules` tool to query the vector database for semantically similar rules. This helps in three ways:
1. **Smarter retries**: The LLM can reason about intent and find rules the engine missed because the error message was slightly different but the underlying problem is the same
2. **Informed rule writing**: When writing a new rule, the LLM can look at how similar problems were solved before instead of starting from scratch
3. **Efficient context**: Instead of dumping every rule into the prompt, the LLM searches for what's relevant, keeping context focused
**Ephemeral Rules**
When the LLM writes a fix, the new rule and action go to `.theow/rules/ephemeral/`. These are unproven until they actually fix the failure. Ephemeral rules persist across multiple LLM conversations within the same exploration session, so each subsequent attempt knows what was tried and why it failed.
Once an ephemeral rule successfully fixes the issue, it gets promoted to the main rules folder and indexed into the vector database for future use.
**Incomplete Rules**
If the LLM hits its session budget before finishing, it can tag the rule as `incomplete` with notes about progress. The next exploration session can pick up where the previous one left off using `list_ephemeral_rules` and `read_ephemeral_rule` tools.
**LLM Configuration**
Set the API key for your provider via environment variable. The agent picks the provider based on the `llm` parameter format in [initialization](#initialization).
| Provider | Format | Environment Variable |
|----------|--------|---------------------|
| Gemini | `gemini/gemini-2.0-flash` | `GEMINI_API_KEY` |
| Anthropic | `anthropic/claude-sonnet-4-20250514` | `ANTHROPIC_API_KEY` |
| Copilot | `copilot/gpt-4o` | `GITHUB_TOKEN` |
### Tools
Tools are how you control what the LLM can do during exploration. They define the boundaries of LLM actions, effectively putting the LLM on a leash. The LLM cannot act outside the tools you register.
Theow provides common tools out of the box:
```python
from theow.tools import read_file, write_file, run_command
pipeline_agent.tool()(read_file)
pipeline_agent.tool()(write_file)
pipeline_agent.tool()(run_command)
```
For tighter control, write custom tools with constraints:
```python
@pipeline_agent.tool()
def read_config(path: str) -> str:
"""Read config files only."""
if not path.endswith((".yaml", ".json")):
raise ValueError("Only config files allowed")
return Path(path).read_text()
@pipeline_agent.tool()
def run_safe_command(cmd: str) -> dict:
"""Run whitelisted commands only."""
allowed = ["ls", "cat", "grep"]
if not any(cmd.startswith(a) for a in allowed):
raise ValueError(f"Command not allowed: {cmd}")
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
return {"stdout": result.stdout, "stderr": result.stderr}
```
This is the key to secure automation. You define the blast radius. The LLM operates within those boundaries.
## LLM Based Actions
Rules can invoke the LLM directly on match instead of running a deterministic action. Useful for failures that need dynamic investigation rather than a fixed fix.
```yaml
name: investigate_unknown
description: Unknown failure, use LLM to investigate
when:
- fact: error_type
equals: unknown
llm_config:
prompt_template: file://prompts/investigate.md # file path or inline string
tools: [read_file, run_command] # tools the LLM can use
constraints:
max_tool_calls: 20
```
Unlike exploration, this does not create new rules. The LLM acts directly on the failure each time the rule matches. Requires an API key for the configured provider.
## Known Limitations
These are known and planned to be addressed:
- **Scale**: Rule matching has not been tested at scale with large rule sets
- **Action chaining**: No intelligent forward or backward chaining. Actions run sequentially in the order defined in the rule
- **Multi-agent**: No multi-agent routing yet. Each Theow instance operates independently
- **Local only**: Rules, actions, vector store must be co-located with the process. No remote rule storage or distributed access yet
- **Vector store**: ChromaDB is the only supported vector store
- **Sync only**: No async support. Execution is synchronous
- **LLM dependency**: Exploration quality depends heavily on the LLM's reasoning ability. Stronger models produce better rules
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | <3.14,>=3.12 | [] | [] | [] | [
"anthropic>=0.40",
"chromadb>=0.4",
"github-copilot-sdk>=0.1",
"google-genai>=0.3",
"pydantic>=2.0",
"pyyaml>=6.0",
"rich>=13.0",
"structlog>=24.0",
"typer>=0.12"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:49:17.862629 | theow-0.0.9.tar.gz | 1,060,449 | 4d/6b/ff022f28367d7b31dc5d22d5289f72bfeeb623dee8ba4bedf1a793b2c009/theow-0.0.9.tar.gz | source | sdist | null | false | e11ae9fd4d6084df9b86085f510f1377 | a46d6fd79c27c21c305ac16239731ae6029e9bf49b34e852ddd3f0344f9cc6d6 | 4d6bff022f28367d7b31dc5d22d5289f72bfeeb623dee8ba4bedf1a793b2c009 | MIT | [
"LICENSE"
] | 214 |
2.4 | python-nhi | 1.3.2 | A function to check strings against the New Zealand Ministry of Health NHI Validation Routine | # NHI
[](https://codeberg.org/jamesansley/nhi)
[](https://codeberg.org/jamesansley/nhi/src/branch/main/LICENSE)
[](https://pypi.org/project/python-nhi/)
A function to check strings against the New Zealand Ministry of Health NHI
Validation Routine.
Supports the old and new NHI number formats specified in
[HISO 10046:2025](https://www.tewhatuora.govt.nz/publications/hiso-100462025-consumer-health-identity-standard/).
## Install
```
pip install python-nhi
```
For the other versions of this library, see:
- [nhi on Hex (Elixir)](https://hex.pm/packages/nhi/0.0.1)
- [nhi on JSR (JavaScript)](https://jsr.io/@ansley/nhi)
- [nhi on Crates (Rust)](https://crates.io/crates/nhi)
- [nhi with Pkl](https://codeberg.org/jamesansley/nhi/src/branch/main/pkl)
## Usage
New format NHI values:
```python
from nhi import is_nhi
is_nhi("ABC12DS") # True
is_nhi("ABC12D0") # False
```
Old format NHI values:
```python
from nhi import is_nhi
is_nhi("AAA1116") # True
is_nhi("AAA1110") # False
```
By default, test NHI values (starting with 'Z') are rejected:
```python
from nhi import is_nhi
is_nhi("ZZZ00AC") # False
```
Test values can be allowed with the allow_test_values flag:
```python
from nhi import is_nhi
is_nhi("ZZZ00AC", allow_test_values=True) # True
```
## See Also
- https://www.tewhatuora.govt.nz/publications/hiso-100462025-consumer-health-identity-standard/
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [
"repository, https://codeberg.org/jamesansley/nhi"
] | twine/6.2.0 CPython/3.13.12 | 2026-02-21T04:48:40.106119 | python_nhi-1.3.2.tar.gz | 7,165 | dc/3f/2ad291517c4cea36a447644603bac13de40f5dea1acfb54827a455457db7/python_nhi-1.3.2.tar.gz | source | sdist | null | false | 74794409fa324eebaae94282e1bbb497 | b9bc266ed0feb737261534d456e0fa37361046cac2ea53332b3c203d043c82c3 | dc3f2ad291517c4cea36a447644603bac13de40f5dea1acfb54827a455457db7 | Apache-2.0 | [
"LICENSE"
] | 221 |
2.4 | bsk | 2.9.1 | Basilisk: an Astrodynamics Simulation Framework | # README
## Basilisk
* [Summary of Basilisk](docs/source/index.rst)
* [Release Notes](docs/source/Support/bskReleaseNotes.rst)
### Installation
Basilisk can be installed in two ways, either from PyPI or by building from
source.
For most users, installing from PyPI is the easiest and fastest way to get
started. Building from source is recommended if you need to link to external
C++ modules or want to customize the build configuration.
#### Install from PyPI
The easiest way to get started with Basilisk is to install the prebuilt wheel
from [PyPI](https://pypi.org/project/bsk/):
```bash
pip install bsk
```
This installs the latest stable version with all standard features
(e.g. optical navigation and MuJoCo). See the [install](docs/source/Install.rst)
docs for supported platforms and additional details about the wheels.
#### Build from Source
If you need to use external C++ modules or want to customize the build, follow
the platform-specific setup instructions:
* [Setup a macOS Development Environment](docs/source/Build/installOnMacOS.rst)
* [Setup a Linux Development Environment](docs/source/Build/installOnLinux.rst)
* [Setup a Windows Development Environment](docs/source/Build/installOnWindows.rst)
See the [Build from Source docs](docs/source/Build.rst) for full details.
### Basilisk Development guidelines
* [Contributing](CONTRIBUTING.md)
* [Coding Guidelines](docs/source/Support/Developer/CodingGuidlines.rst)
### Getting Started
To get started with Basilisk (BSK), several tutorial python files are provided in the installed package. Within this
web page documentation site, they are listed and discussed in the [integrated example script](docs/source/examples/index.rst) page.
The documentation lists the scenarios in an order that facilitates learning basic BSK features. The python scripts
are stored in the repository under `basilisk/examples`. A good start would be to run `scenarioBasicOrbit.py`.
If you downloaded Basilisk through `pip install bsk`, then you can download all examples to the local folder using the command line `bskExamples`.
To play with the tutorials, it is suggested the user makes a copy of these tutorial files, and use the copies in order
to learn, test and experiment. Copy the folder `basilisk/examples` into a
new folder, and change to that directory.
To run the default scenario of `scenarioBasicOrbit`, in the directory of the
copied tutorials, execute the python script: `python scenarioBasicOrbit.py`
Now, when you want to use a tutorial, navigate inside that folder, and edit and execute the *copied* integrated tests.
Any new BSK module development should not occur within the BSK folder as this will be updated rapidly. Rather,
new FSW algorithm or simulation code modules should be created in a custom folder outside of the BSK directory.
See the [building custom modules](docs/source/Build/buildExtModules.rst) web page
for more information.
To use the standalone 3D Visualization, download the [Vizard](docs/source/Vizard/VizardDownload.rst).
This is in development, but does provide a 3D view of many of the simulation states.
### Who do I talk to?
Questions and answers are fielded in the project's [Github Discussions](https://github.com/AVSLab/basilisk/discussions).
| text/markdown | null | null | null | null | ISC License
Copyright (c) 2016, Autonomous Vehicle Systems Lab, University of Colorado at Boulder
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
| null | [] | [] | https://avslab.github.io/basilisk/ | null | <3.14,>=3.8 | [] | [] | [] | [
"pandas<=2.2.3,>=2.0.3; python_version < \"3.9\"",
"pandas<=2.3.3,>=2.0.3; python_version >= \"3.9\"",
"matplotlib<=3.10.7,>=3.7.5",
"numpy<2.4.0,>=1.24.4; python_version < \"3.13\"",
"numpy<2.4.0,>=2.0; python_version >= \"3.13\"",
"colorama==0.4.6",
"tqdm==4.67.1",
"pillow<=12.0.0,>=10.4.0",
"requests<=2.32.5,>=2.32.3",
"bokeh<=3.8.1,>=3.1.1",
"protobuf<=6.33.1,>=5.29.4",
"pooch<1.9,>=1.7.0",
"psutil; extra == \"test\"",
"pytest-error-for-skips; extra == \"test\"",
"pytest; extra == \"test\""
] | [] | [] | [] | [
"homepage, https://avslab.github.io/basilisk/",
"source, https://github.com/AVSLab/basilisk",
"tracker, https://github.com/AVSLab/basilisk/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:47:40.525958 | bsk-2.9.1.tar.gz | 29,444,548 | 36/65/0d4e66f0a7fa5c86d96ecc235e785b65f55f6cb0b5157615541188bc2b56/bsk-2.9.1.tar.gz | source | sdist | null | false | 50b5ba4e50f498d93657cdec0be2fb09 | fd33142f0f917e2fab52fb7221d80c4b1d07ab26a8d216d6620501ccb62f6dab | 36650d4e66f0a7fa5c86d96ecc235e785b65f55f6cb0b5157615541188bc2b56 | null | [
"LICENSE"
] | 398 |
2.4 | minicorn | 1.2.0 | minicorn - A lightweight, production-grade synchronous WSGI server with auto-reload support | # minicorn 🐣🦄🔥
A lightweight, production-grade Python server that speaks both **WSGI** and **ASGI** — with full **WebSocket** support baked in.
minicorn gives you a Uvicorn/Gunicorn-like CLI experience with zero heavyweight dependencies, serving everything from classic Flask apps to modern async FastAPI services over the same port.
## Features
| | |
|---|---|
| 🐍 **WSGI** | Full PEP 3333 compliance — Flask, Django, and any WSGI app |
| ⚡ **ASGI** | Async support for FastAPI, Starlette, and ASGI 3.0 apps |
| 🔌 **WebSockets** | RFC 6455 compliant WebSocket handling in ASGI mode |
| 🔄 **Auto-reload** | File-watching hot reload for development |
| 🛠️ **Simple CLI** | One command to run any app, WSGI or ASGI |
| 📦 **Zero Core Deps** | Stdlib only — `watchdog` needed only for `--reload` |
| 📋 **Structured Logging** | Colored, leveled log output |
## Installation
```bash
pip install minicorn
# With dev/reload support
pip install "minicorn[dev]"
```
## Quick Start
### WSGI — Flask / Django
```bash
# Run a Flask or Django app
minicorn main:app
# Custom host and port
minicorn main:app --host 0.0.0.0 --port 8080
# Hot reload during development
minicorn main:app --reload
```
### ASGI — FastAPI / Starlette
Add `--asgi` to switch to async mode:
```bash
# Run a FastAPI app
minicorn main:app --asgi
# With hot reload
minicorn main:app --asgi --reload
# Custom port
minicorn main:app --asgi --port 8080
```
### WebSockets
WebSocket support is built into ASGI mode — no extra flags needed.
Any endpoint that upgrades to WebSocket (HTTP 101) is handled automatically.
```bash
minicorn main:app --asgi
# ws://127.0.0.1:8000/ws is ready to accept connections
```
Enable keepalive pings to detect dead connections:
```bash
minicorn main:app --asgi --ws-ping-interval 20 --ws-ping-timeout 10
```
### Using with Python -m
```bash
python -m minicorn main:app --reload
python -m minicorn main:app --asgi --reload
```
## Example Apps
### Flask (WSGI)
```python
# main.py
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello from minicorn! 🔥"
```
```bash
minicorn main:app --reload
```
### FastAPI (ASGI)
```python
# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def root():
return {"message": "Hello from FastAPI!", "server": "minicorn-asgi"}
```
```bash
minicorn main:app --asgi --reload
```
### WebSocket with FastAPI
```python
# main.py
from fastapi import FastAPI, WebSocket
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
while True:
data = await websocket.receive_text()
await websocket.send_text(f"Echo: {data}")
```
```bash
minicorn main:app --asgi
# Connect to ws://127.0.0.1:8000/ws
```
## Programmatic Usage
```python
# WSGI
from minicorn import serve, run
serve("main:app", host="0.0.0.0", port=8080)
# or pass the app object directly
from myapp import app
run(app, host="127.0.0.1", port=8000)
```
```python
# ASGI
from minicorn import serve_asgi, run_asgi
serve_asgi("main:app", host="0.0.0.0", port=8080)
from myapp import app
run_asgi(app, host="127.0.0.1", port=8000)
```
## CLI Reference
```
minicorn --help
```
## Auto-Reload
`--reload` works for both WSGI and ASGI. minicorn watches `.py` files in your project and restarts the server on changes.
```bash
minicorn main:app --reload # WSGI
minicorn main:app --asgi --reload # ASGI
```
Automatically ignored: `__pycache__`, `.git`, `venv`, `.venv`, `node_modules`, `dist`, `build`, `.mypy_cache`, `.pytest_cache`
## Server Capabilities
| Capability | WSGI | ASGI |
|---|:---:|:---:|
| HTTP/1.0 & HTTP/1.1 | ✅ | ✅ |
| Keep-Alive connections | ✅ | ✅ |
| Chunked transfer encoding | ✅ | ✅ |
| Streaming responses | ✅ | ✅ |
| WebSocket (RFC 6455) | — | ✅ |
| WebSocket ping/pong | — | ✅ |
| asyncio-based concurrency | — | ✅ |
| Auto-reload | ✅ | ✅ |
## Configuration Defaults
| Setting | Default | Description |
|---|---|---|
| Host | `127.0.0.1` | Bind address |
| Port | `8000` | Bind port |
| Max Header Size | 64 KB | Reject oversized headers |
| Max Body Size | 1 MB | Reject oversized bodies |
| Recv Timeout | 10s | Timeout waiting for request data |
| Keep-Alive Timeout | 15s | Idle timeout between requests |
| Max Keep-Alive Requests | 100 | Max requests per connection |
| WS Max Message Size | 16 MB | Maximum WebSocket message size |
| WS Ping Interval | disabled | Ping clients every N seconds |
| WS Ping Timeout | disabled | Close if pong not received in N seconds |
## License
MIT License
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
| text/markdown | null | Bhavani Shankar Mukka <shankarbhavani862@gmail.com> | null | null | MIT | wsgi, server, web, http, flask, django | [
"Development Status :: 4 - Beta",
"Environment :: Web Environment",
"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 :: Internet :: WWW/HTTP :: HTTP Servers",
"Topic :: Internet :: WWW/HTTP :: WSGI :: Server"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"watchdog>=3.0.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/Shankar-105/minicorn",
"Documentation, https://github.com/Shankar-105/minicorn#readme",
"Repository, https://github.com/Shankar-105/minicorn"
] | twine/6.2.0 CPython/3.14.0 | 2026-02-21T04:46:53.238267 | minicorn-1.2.0.tar.gz | 29,959 | b6/4a/d49cad20362cd5023279eb065d82a42e64cc957603098befe3afbb6b7880/minicorn-1.2.0.tar.gz | source | sdist | null | false | e2b6304111e0ad9a15ee43c80427e028 | 8ebbb0a3a139adb09525f1108412909f6a1393f00dded378512473523ee737f6 | b64ad49cad20362cd5023279eb065d82a42e64cc957603098befe3afbb6b7880 | null | [
"LICENSE"
] | 230 |
2.4 | kanbus | 0.11.0 | A git-backed project management system. | # Kanbus
**A tiny Jira clone for your repo.**
## Inspiration & Lineage
Kanbus is a spiritual successor to [Beads](https://github.com/steveyegge/beads), inspired by its elegant, domain-specific approach to project management. We are deeply grateful to the Beads author and community for proving that a dedicated cognitive framework for tasks is game-changing.
Kanbus builds on this foundation by adapting the model to be a thinner, more native layer over Git—optimizing for AI agents and distributed teams:
* **A Thinner Layer over Git**: We removed the secondary SQLite index. The complexity of maintaining and synchronizing a shadow database isn't worth the operational cost. Kanbus reads files directly.
* **Better Storage Alignment**: Things like "exclusively claiming" a task don't align well with the distributed Git model. We removed them to ensure the tool behaves exactly like the version control system underneath it.
* **Conflict-Free Storage**: Instead of a single JSON-L file (which guarantees merge conflicts when agents work in parallel), Kanbus stores separate tasks in separate files. This eliminates conflicts and allows deep linking to specific issues from GitHub.
* **Streamlined Cognitive Model**: Beads is powerful but complex, with 130+ attributes per issue. We streamlined this to a focused core (Status, Priority, Dependencies) to reduce the "context pollution" for AI agents. We want the model to think about the work, not how to use the tracker. The goal is a **helpful cognitive model** that unburdens your mental state rather than adding to it.
* **AI-Native Nomenclature**: Instead of teaching models new terms like "beads", we use the standard Jira vocabulary (Epics, Tasks, Sub-tasks) that AI models are already extensively pre-trained on. This leverages their existing knowledge graph for better reasoning.
* **Git-Native Scoping**: We replaced complex "contributor roles" with standard Git patterns. Want local tasks? Just `.gitignore` a folder. Working in a monorepo? Kanbus respects your current directory scope automatically.
## Frictionless Workflow
Kanbus is designed to **remove friction**, not add it.
* **No Syncing**: There is no secondary database to synchronize. The files on disk are the source of truth. You will never be blocked from pushing code because a background daemon is out of sync.
* **Git Hooks Help You**: Git hooks should assist your workflow, not interrupt it. Kanbus hooks are designed to be invisible helpers, ensuring data integrity without stopping you from getting work done.
For a detailed comparison, see [Kanbus vs. Beads](docs/VS_BEADS.md).
## Why Kanbus?
### 1. The Sleep Factor
Offload your mental context. Instead of keeping 15 different chat sessions and open loops in your head, tell your agent to "record the current state" into Kanbus. It's a permanent, searchable memory bank for your AI workforce.
### 2. Files are the Database
- **No SQL Server**: We removed the SQLite daemon entirely. Each command reads the JSON files directly, so there is nothing to synchronize or keep running.
- **No JSONL Merge Conflicts**: There is no monolithic JSONL file. Every issue has its own JSON document, which eliminates merge conflicts when teams (or agents) edit work in parallel.
- **No Daemon**: There is no background process to crash or manage.
- **No API**: Your agents read and write files directly (or use the simple CLI).
### 3. Concurrency Solved
Unlike other file-based systems that use a single JSONL file (guaranteeing merge conflicts), Kanbus stores **one issue per file**. This allows multiple agents and developers to work in parallel without blocking each other.
### 4. Jira + Confluence for Agents
Kanbus includes a **Wiki Engine** that renders Markdown templates with live issue data. Your planning documents always reflect the real-time state of the project, giving agents the "forest view" they often lack.
### 5. Zero Cost Footprint
There are no per-seat licenses or hosted fees. If you have a git repository, you already have the database—and that keeps Kanbus affordable for very large teams (or fleets of agents).
---
## Status: Planning Phase
This repository contains the complete vision, implementation plan, and task breakdown for building Kanbus. We are building it in public, using Kanbus to track itself.
## Quick Start
```bash
# Initialize a new project
kanbus init
# Create an issue
kanbus create "Implement the login flow"
# List open tasks
kanbus list --status todo
# Show details
kanbus show kanbus-a1b
```
## Daemon Behavior
Kanbus uses a just-in-time index daemon for read-heavy commands such as `kanbus list`. The CLI auto-starts the daemon when needed, reuses a healthy socket, and removes stale sockets before restarting.
To disable daemon mode for a command:
```bash
KANBUS_NO_DAEMON=1 kanbus list
```
Operational commands:
```bash
kanbus daemon-status
kanbus daemon-stop
```
## Python vs Rust
We provide two implementations driven by the same behavior specification:
**Choose Python if:**
- You want easy `pip install` with no compilation
- You are scripting custom agent workflows
**Choose Rust if:**
- You need maximum performance (sub-millisecond queries)
- You have a massive repository (> 2000 issues)
## Project Structure
```
Kanbus/
|-- planning/
| |-- VISION.md # Complete specification
| `-- IMPLEMENTATION_PLAN.md # Detailed technical plan
|-- specs/ # Shared Gherkin feature files
|-- python/ # Python implementation
|-- rust/ # Rust implementation
|-- apps/ # Public website (Gatsby)
`-- .beads/ # Project task database
```
## Contributing
We welcome contributions! Please:
1. Pick a task from `kanbus ready`.
2. Follow the BDD workflow in [AGENTS.md](AGENTS.md).
3. Ensure all quality gates pass.
## Testing
Run the full quality gates:
```bash
make check-all
```
Run only Python checks:
```bash
make check-python
```
Run only Rust checks:
```bash
make check-rust
```
## Benchmarking
Run index build and cache load benchmarks:
```bash
python tools/benchmark_index.py
cd rust && cargo run --release --bin index_benchmark
```
## License
MIT
| text/markdown | null | null | null | null | null | null | [
"Development Status :: 3 - Alpha",
"Environment :: Console",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Bug Tracking",
"Topic :: Software Development :: Version Control"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"click",
"jinja2",
"pydantic",
"pyyaml",
"pydantic-settings",
"requests",
"behave",
"coverage",
"ruff",
"black",
"sphinx"
] | [] | [] | [] | [
"Homepage, https://kanb.us",
"Repository, https://github.com/AnthusAI/Kanbus",
"Issues, https://github.com/AnthusAI/Kanbus/issues"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-21T04:46:16.067715 | kanbus-0.11.0.tar.gz | 67,198 | ab/28/fb48349a85cbe71b084e4b1b7ce3cdb17fd2e4a0636d1f633047dfd6fca6/kanbus-0.11.0.tar.gz | source | sdist | null | false | f5e01a4fe4a702eb6e79ebde48f0b39d | 441db5d03ba3fdb8f79f7d1773296fdda48b4c37df3282e9022692fb4bd3f905 | ab28fb48349a85cbe71b084e4b1b7ce3cdb17fd2e4a0636d1f633047dfd6fca6 | MIT | [] | 217 |
2.4 | multi-user-gymnasium | 0.1.2 | A platform for running interactive experiments in the browser with standard simulation environments. | # Multi-User Gymnasium (MUG)
<div align="center">
<img src="docs/content/mug_logo.png" alt="MUG logo" width="300"/>
</div>
Multi-User Gymnasium (MUG) converts Gymnasium and PettingZoo environments into browser-based, multi-user experiments. It enables Python simulation environments to be accessed online, allowing humans to interact with them individually or alongside AI agents and other participants.
## Multiplayer Configuration
For P2P multiplayer experiments, MUG uses WebRTC for low-latency peer-to-peer connections. When direct P2P connections fail (due to firewalls, NAT, or restrictive networks), a TURN server provides relay fallback.
**Setting up TURN credentials:**
1. Sign up for a free TURN server at [Open Relay (metered.ca)](https://www.metered.ca/tools/openrelay/) (free tier: 20GB/month)
2. Set environment variables with your credentials:
```bash
export TURN_USERNAME="your-openrelay-username"
export TURN_CREDENTIAL="your-openrelay-api-key"
```
3. Enable WebRTC in your experiment configuration:
```python
from mug.configurations import RemoteConfig
config = RemoteConfig()
config.webrtc() # Auto-loads from TURN_USERNAME and TURN_CREDENTIAL env vars
```
**Alternative: Using a .env file**
Create a `.env` file (add to `.gitignore`):
```text
TURN_USERNAME=your-openrelay-username
TURN_CREDENTIAL=your-openrelay-api-key
```
Then load it in your experiment:
```python
from dotenv import load_dotenv
load_dotenv()
config = RemoteConfig()
config.webrtc()
```
**Testing TURN relay:**
To force all connections through TURN (useful for testing):
```python
config.webrtc(force_relay=True)
```
## Acknowledgements
The Phaser integration and server implementation are inspired by and derived from the
Overcooked AI demo by Carroll et al. (https://github.com/HumanCompatibleAI/overcooked-demo/tree/master).
| text/markdown | null | Chase McDonald <chasecmcdonald@gmail.com> | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"numpy",
"eventlet; extra == \"server\"",
"flask; extra == \"server\"",
"flask-login>=0.6.3; extra == \"server\"",
"flask-socketio; extra == \"server\"",
"gymnasium; extra == \"server\"",
"msgpack; extra == \"server\"",
"pandas; extra == \"server\"",
"flatten_dict; extra == \"server\"",
"pytest>=8.0; extra == \"test\"",
"playwright>=1.49; extra == \"test\"",
"pytest-playwright>=0.6; extra == \"test\"",
"pytest-timeout>=2.3; extra == \"test\""
] | [] | [] | [] | [] | twine/6.0.1 CPython/3.10.14 | 2026-02-21T04:45:26.650986 | multi_user_gymnasium-0.1.2.tar.gz | 251,205 | ac/5b/f042fb0128296f5468a94c698e9c148e93cc4515c89caa90a0bc0404db48/multi_user_gymnasium-0.1.2.tar.gz | source | sdist | null | false | fafeddb9db7d18c685819983a85e708b | fd83f23ca30576701ed660820a227fee10768bed215d0f3d753072fb3ac9b1bf | ac5bf042fb0128296f5468a94c698e9c148e93cc4515c89caa90a0bc0404db48 | null | [] | 353 |
2.4 | simple-log-factory-ext-otel | 1.5.0 | OpenTelemetry log handler and tracing plugin for simple_log_factory | # simple-log-factory-ext-otel
OpenTelemetry log handler and tracing plugin for [simple_log_factory](https://github.com/raccoon/simple-log-factory).
Ship your log messages **and traces** to any OpenTelemetry-compatible backend (Tempo, Jaeger, Grafana Cloud, SigNoz, etc.) without changing any existing logging code.
## Installation
```bash
pip install simple-log-factory-ext-otel
```
Or with [UV](https://docs.astral.sh/uv/):
```bash
uv add simple-log-factory-ext-otel
```
## Quick Start
### Pattern 1 — Logs Only
```python
from simple_log_factory import log_factory
from simple_log_factory_ext_otel import OtelLogHandler
# 1. Initialize the handler
otel_handler = OtelLogHandler(
service_name="my-service",
endpoint="http://localhost:4317",
)
# 2. Pass it to log_factory — done
logger = log_factory(
__name__,
custom_handlers=[otel_handler],
)
logger.info("This goes to console AND to your OTel backend")
# 3. Clean shutdown (optional but recommended)
otel_handler.shutdown()
```
### Pattern 2 — All-in-One with `otel_log_factory()`
```python
from simple_log_factory_ext_otel import otel_log_factory
# One call — creates logger, OTel handler, and tracer
traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://localhost:4318",
)
# Logging works immediately
traced.info("Service started")
# Spans are ready too
with traced.span("process-order", attributes={"order.id": "123"}):
traced.info("Processing order")
# Subsequent calls with the same endpoint/service/log_name return the
# cached instance (cache_logger=True by default)
same_traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://localhost:4318",
)
assert same_traced is traced
# Different service names or endpoints get independent loggers
payments_traced = otel_log_factory(
service_name="payment-service",
otel_exporter_endpoint="http://localhost:4318",
)
```
### Pattern 3 — Logs + Tracing with `setup_otel()`
```python
from simple_log_factory import log_factory
from simple_log_factory_ext_otel import setup_otel, TracedLogger
# 1. One-call setup — creates both log handler and tracer
# with a shared Resource; registers TracerProvider globally
handler, otel_tracer = setup_otel(
service_name="my-service",
endpoint="http://localhost:4317",
)
# 2. Create a logger with the OTel handler
logger = log_factory(__name__, custom_handlers=[handler])
# 3. Wrap with TracedLogger for span support
traced = TracedLogger(logger=logger, tracer=otel_tracer.tracer)
# 4. Use span() to create correlated spans
with traced.span("process-order", attributes={"order.id": "123"}):
traced.info("Processing order") # auto-correlated with the span
# ... your business logic ...
# 5. Or use @trace() as a decorator
@traced.trace("fetch-user")
def fetch_user(user_id: int) -> dict:
traced.info("Fetching user %d", user_id)
return {"id": user_id, "name": "Alice"}
fetch_user(42)
```
### Database Tracing
Instrument your PostgreSQL driver so every SQL query creates an OTel span automatically.
**Install the extra(s) you need:**
```bash
pip install simple-log-factory-ext-otel[psycopg2] # psycopg2 only
pip install simple-log-factory-ext-otel[psycopg] # psycopg (v3) only
pip install simple-log-factory-ext-otel[db] # all DB drivers
```
**Style 1 — Via `otel_log_factory()` (most drop-in)**
```python
from simple_log_factory_ext_otel import otel_log_factory
traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://otel-alloy:4318",
instrument_db={"psycopg2": {"enable_commenter": True}},
)
# That's it — all psycopg2 queries now produce OTel CLIENT spans.
```
**Style 2 — Via `TracedLogger` method**
```python
traced.instrument_db("psycopg2", enable_commenter=True)
```
**Style 3 — Standalone function**
```python
from simple_log_factory_ext_otel import instrument_db
instrument_db("psycopg2")
```
The `enable_commenter` option appends SQL comments with trace context to
queries, which is useful for correlating traces with `pg_stat_statements`.
### Requests Tracing (Outgoing HTTP)
Instrument the `requests` library so every outgoing HTTP call creates an OTel span automatically.
**Install the extra:**
```bash
pip install simple-log-factory-ext-otel[requests]
```
**Style 1 — Via `otel_log_factory()` (most drop-in)**
```python
from simple_log_factory_ext_otel import otel_log_factory
traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://otel-alloy:4318",
instrument_requests=True,
)
# All requests.get/post/… calls now produce OTel CLIENT spans.
# To exclude certain URLs from tracing:
traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://otel-alloy:4318",
instrument_requests={"excluded_urls": "health,ready"},
)
```
**Style 2 — Via `TracedLogger` method**
```python
traced.instrument_requests()
# or with exclusions:
traced.instrument_requests(excluded_urls="health,ready")
```
**Style 3 — Standalone function**
```python
from simple_log_factory_ext_otel import instrument_requests
instrument_requests()
# or with exclusions:
instrument_requests(excluded_urls="health,ready")
```
The `excluded_urls` parameter accepts a comma-delimited string of regex
patterns for URLs that should not be traced.
### FastAPI Tracing (Incoming HTTP)
Instrument FastAPI so every incoming HTTP request creates an OTel span automatically.
**Install the extra:**
```bash
pip install simple-log-factory-ext-otel[fastapi]
```
**Style 1 — Via `otel_log_factory()` (most drop-in)**
```python
from fastapi import FastAPI
from simple_log_factory_ext_otel import otel_log_factory
app = FastAPI()
# Global instrumentation (all FastAPI apps):
traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://otel-alloy:4318",
instrument_fastapi=True,
)
# App-specific instrumentation:
traced = otel_log_factory(
service_name="my-service",
otel_exporter_endpoint="http://otel-alloy:4318",
instrument_fastapi={"app": app, "excluded_urls": "health"},
)
```
**Style 2 — Via `TracedLogger` method**
```python
traced.instrument_fastapi() # global
traced.instrument_fastapi(app=app) # app-specific
traced.instrument_fastapi(excluded_urls="health") # with exclusions
```
**Style 3 — Standalone function**
```python
from simple_log_factory_ext_otel import instrument_fastapi
instrument_fastapi() # global
instrument_fastapi(app=app) # app-specific
instrument_fastapi(excluded_urls="health") # with exclusions
```
The `excluded_urls` parameter accepts a comma-delimited string of regex
patterns for URLs that should not be traced.
### Cross-Resource Instrumentation
To install all HTTP instrumentation extras at once:
```bash
pip install simple-log-factory-ext-otel[cross-resource]
```
This installs both `requests` and `fastapi` instrumentation packages.
## Configuration
### `OtelLogHandler` Parameters
| Parameter | Type | Default | Description |
|-------------------------|------------------|-------------------------|-------------------------------------------------|
| `service_name` | `str` | *(required)* | Logical name of the service emitting logs |
| `endpoint` | `str` | `http://localhost:4317` | OTLP receiver endpoint |
| `protocol` | `str` | `"grpc"` | Transport protocol — `"grpc"` or `"http"` |
| `insecure` | `bool` | `True` | Use plaintext (insecure) connection |
| `headers` | `Dict[str, str]` | `None` | Metadata headers sent with every export request |
| `resource_attributes` | `Dict[str, str]` | `None` | Extra OTel Resource attributes |
| `log_level` | `int` | `logging.NOTSET` | Minimum severity forwarded to the OTel pipeline |
| `export_timeout_millis` | `int` | `30000` | Timeout in ms for each export batch |
### Using HTTP Instead of gRPC
```python
from simple_log_factory_ext_otel import OtelLogHandler
handler = OtelLogHandler(
service_name="my-service",
endpoint="http://localhost:4318/v1/logs",
protocol="http",
)
```
### Custom Resource Attributes
```python
from simple_log_factory_ext_otel import OtelLogHandler
handler = OtelLogHandler(
service_name="my-service",
resource_attributes={
"deployment.environment": "production",
"service.version": "1.2.3",
},
)
```
### Authenticated Endpoints
```python
from simple_log_factory_ext_otel import OtelLogHandler
handler = OtelLogHandler(
service_name="my-service",
endpoint="https://otel.example.com:4317",
insecure=False,
headers={"Authorization": "Bearer <token>"},
)
```
### Level Filtering
Only export warnings and above to your OTel backend:
```python
import logging
from simple_log_factory_ext_otel import OtelLogHandler
handler = OtelLogHandler(
service_name="my-service",
log_level=logging.WARNING,
)
```
### `TracedLogger` API
`TracedLogger` wraps a standard `logging.Logger` and an OTel `Tracer`:
- **`span(name, attributes)`** — context manager that creates an OTel span. Logs inside the block are auto-correlated.
- **`trace(name, attributes)`** — decorator that wraps a function in a span. Exceptions are recorded on the span and re-raised.
- **`debug/info/warning/error/exception/critical/log`** — proxy to the underlying logger.
- **`logger` / `tracer`** properties — escape hatches for direct access.
### `setup_otel()` Parameters
| Parameter | Type | Default | Description |
|-------------------------|------------------|-------------------------|--------------------------------------------------|
| `service_name` | `str` | *(required)* | Logical name of the service |
| `endpoint` | `str` | `http://localhost:4317` | OTLP receiver endpoint |
| `protocol` | `str` | `"grpc"` | Transport protocol — `"grpc"` or `"http"` |
| `insecure` | `bool` | `True` | Use plaintext (insecure) connection |
| `headers` | `Dict[str, str]` | `None` | Metadata headers sent with every export request |
| `resource_attributes` | `Dict[str, str]` | `None` | Extra OTel Resource attributes |
| `export_timeout_millis` | `int` | `30000` | Timeout in ms for each export batch |
| `log_level` | `int` | `logging.NOTSET` | Minimum severity forwarded to the OTel pipeline |
Returns a `(OtelLogHandler, OtelTracer)` tuple. The `TracerProvider` is registered globally so auto-instrumentation libraries (FastAPI, psycopg2, etc.) share the same provider.
### `otel_log_factory()` Parameters
| Parameter | Type | Default | Description |
|--------------------------|--------|----------------|---------------------------------------------------------------------------------|
| `service_name` | `str` | *(required)* | Logical name of the service |
| `otel_exporter_endpoint` | `str` | *(required)* | Base URL of the OTel collector (e.g. `http://localhost:4318`) |
| `log_name` | `str` | `service_name` | Name passed to `log_factory`. Defaults to `service_name` when `None` |
| `cache_logger` | `bool` | `True` | Cache and reuse the logger for the same endpoint/service/log-name combo |
| `use_http_protocol` | `bool` | `True` | `True` for HTTP (appends `/v1/logs` and `/v1/traces`), `False` for gRPC |
| `instrument_db` | `dict` | `None` | DB drivers to auto-instrument — e.g. `{"psycopg2": {"enable_commenter": True}}` |
| `instrument_requests` | `bool \| dict` | `None` | `True` for defaults or `dict` of kwargs — e.g. `{"excluded_urls": "health"}` |
| `instrument_fastapi` | `bool \| dict` | `None` | `True` for defaults or `dict` of kwargs — e.g. `{"app": app, "excluded_urls": "health"}` |
| `**kwargs` | | | Extra keyword arguments forwarded to `simple_log_factory.log_factory` |
Returns a `TracedLogger` with both logging and tracing configured. The `TracerProvider` is registered globally. Loggers are cached by the composite key `(otel_exporter_endpoint, service_name, log_name)`, so different services or endpoints get independent loggers.
## How It Works
`OtelLogHandler` extends `logging.Handler` directly (not OTel's `LoggingHandler`) and internally composes the OTel pipeline:
```
Your code
└─► log_factory (attaches handler, sets formatter & level)
└─► OtelLogHandler.emit(record)
└─► Internal OTel LoggingHandler (LogRecord → OTel translation)
└─► BatchLogRecordProcessor
└─► OTLPLogExporter (gRPC or HTTP)
└─► OTel Collector / Backend
```
This composition pattern is critical: `log_factory` calls `setFormatter()` and `setLevel()` on every handler it receives. If we inherited from OTel's `LoggingHandler`, the factory's formatter would overwrite OTel's internal translation. By wrapping it, both pipelines stay independent.
### Trace Context Correlation
When using `setup_otel()` or sharing a `Resource` between `OtelLogHandler` and `OtelTracer`, span and trace IDs are automatically attached to log records emitted inside active spans. No extra configuration needed.
## Lifecycle Management
The handler registers an `atexit` hook to flush and shut down on interpreter exit. For explicit control:
```python
# Force-flush buffered records
otel_handler.flush()
# Graceful shutdown (idempotent, safe to call multiple times)
otel_handler.shutdown()
```
## Local Development
Create a virtual environment with [UV](https://docs.astral.sh/uv/):
```bash
uv venv
uv pip install -e ".[dev]"
```
Run tests:
```bash
pytest --cov=simple_log_factory_ext_otel --cov-report=term-missing
```
Run linters:
```bash
black --check .
isort --check .
ruff check .
mypy simple_log_factory_ext_otel
```
## License
GPL-3.0 — see [LICENSE.md](LICENSE.md) for details.
| text/markdown | Breno RdV | null | null | null | null | logging, opentelemetry, otel, observability, simple-log-factory, tracing, traces, spans | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: System :: Logging",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"opentelemetry-api>=1.20.0",
"opentelemetry-sdk>=1.20.0",
"opentelemetry-exporter-otlp-proto-grpc>=1.20.0",
"opentelemetry-exporter-otlp-proto-http>=1.20.0",
"opentelemetry-instrumentation-psycopg2>=0.60b1; extra == \"psycopg2\"",
"opentelemetry-instrumentation-psycopg>=0.60b1; extra == \"psycopg\"",
"opentelemetry-instrumentation-psycopg2>=0.60b1; extra == \"db\"",
"opentelemetry-instrumentation-psycopg>=0.60b1; extra == \"db\"",
"opentelemetry-instrumentation-requests>=0.60b1; extra == \"requests\"",
"opentelemetry-instrumentation-fastapi>=0.60b1; extra == \"fastapi\"",
"opentelemetry-instrumentation-requests>=0.60b1; extra == \"cross-resource\"",
"opentelemetry-instrumentation-fastapi>=0.60b1; extra == \"cross-resource\"",
"pytest>=7.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"black>=23.0; extra == \"dev\"",
"isort>=5.0; extra == \"dev\"",
"mypy>=1.0; extra == \"dev\"",
"ruff>=0.15.1; extra == \"dev\"",
"simple-log-factory>=1.0.0; extra == \"dev\"",
"opentelemetry-instrumentation-psycopg2>=0.60b1; extra == \"dev\"",
"opentelemetry-instrumentation-psycopg>=0.60b1; extra == \"dev\"",
"opentelemetry-instrumentation-requests>=0.60b1; extra == \"dev\"",
"opentelemetry-instrumentation-fastapi>=0.60b1; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/raccoon/simple-log-factory-ext-otel",
"Repository, https://github.com/raccoon/simple-log-factory-ext-otel",
"Issues, https://github.com/raccoon/simple-log-factory-ext-otel/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:44:42.067708 | simple_log_factory_ext_otel-1.5.0.tar.gz | 39,597 | 51/5e/161d3d7ec9a5c25b56f6b5e3eee14059c21687b828b5871276f801a49210/simple_log_factory_ext_otel-1.5.0.tar.gz | source | sdist | null | false | 14b46ee4c482c9af62fb7209a572678c | a4fc2c514b6b6d624b70e9cb3ac4d479fcfc414b94d951139ff5605f04a5947e | 515e161d3d7ec9a5c25b56f6b5e3eee14059c21687b828b5871276f801a49210 | GPL-3.0-only | [
"LICENSE.md"
] | 225 |
2.4 | agent-bom | 0.17.0 | AI Bill of Materials (AI-BOM) generator — CVE scanning, blast radius, enterprise remediation plans, OWASP LLM Top 10 + MITRE ATLAS + NIST AI RMF threat mapping, LLM-powered enrichment, OpenClaw discovery, MCP runtime introspection, and MCP registry for AI agents. | <p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/logo-dark.svg">
<img src="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/logo-light.svg" alt="agent-bom" width="480" />
</picture>
</p>
<p align="center">
<a href="https://github.com/agent-bom/agent-bom/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/agent-bom/agent-bom/ci.yml?style=flat&logo=github&label=Build" alt="Build"></a>
<a href="https://pypi.org/project/agent-bom/"><img src="https://img.shields.io/pypi/v/agent-bom?style=flat&label=Latest%20version" alt="PyPI"></a>
<a href="https://hub.docker.com/r/agentbom/agent-bom"><img src="https://img.shields.io/docker/pulls/agentbom/agent-bom?style=flat&label=Docker%20pulls" alt="Docker"></a>
<a href="https://github.com/agent-bom/agent-bom/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue?style=flat" alt="License"></a>
<a href="https://securityscorecards.dev/viewer/?uri=github.com/agent-bom/agent-bom"><img src="https://api.securityscorecards.dev/projects/github.com/agent-bom/agent-bom/badge" alt="OpenSSF"></a>
<a href="https://github.com/agent-bom/agent-bom/stargazers"><img src="https://img.shields.io/github/stars/agent-bom/agent-bom?style=flat&logo=github&label=Stars" alt="Stars"></a>
</p>
<p align="center">
<b>Generate AI Bills of Materials. Scan AI agents and MCP servers for CVEs. Map blast radius. Enterprise remediation with named assets and risk narratives. OWASP LLM Top 10 + MITRE ATLAS + NIST AI RMF.</b>
</p>
<p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/architecture-dark.svg">
<img src="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/architecture-light.svg" alt="agent-bom architecture" width="800" style="padding: 20px 0" />
</picture>
</p>
<p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/blast-radius-dark.svg">
<img src="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/blast-radius-light.svg" alt="Blast radius attack surface" width="800" style="padding: 20px 0" />
</picture>
</p>
---
## Why agent-bom?
<table>
<tr>
<td width="55%" valign="top">
**Not just "this package has a CVE."**
agent-bom answers the question security teams actually need:
> *If this CVE is exploited, which AI agents are compromised, which credentials leak, and which tools can an attacker reach?*
- **AI-BOM generation** — structured inventory of agents, servers, packages, credentials, tools
- **Blast radius analysis** — maps CVEs to agents, credentials, and MCP tools
- **Enterprise remediation** — named assets, impact percentages, risk narratives per fix
- **OWASP LLM Top 10 + MITRE ATLAS + NIST AI RMF** — triple threat framework tagging on every finding
- **AI-powered enrichment** — LLM-generated risk narratives, executive summaries, and threat chains via `--ai-enrich`
- **109-server MCP registry** — risk levels, risk justifications, tool inventories, detail pages (incl. OpenClaw)
- **Policy-as-code** — block unverified servers, enforce risk thresholds in CI
- **Read-only** — never writes configs, never runs servers, never stores secrets
- **Works everywhere** — CLI, Docker, REST API, Cloud UI, CI/CD, Prometheus, Kubernetes
</td>
<td width="45%" valign="top">
**What it scans:**
| Source | How |
|--------|-----|
| MCP configs | Auto-discover (9 clients incl. OpenClaw) |
| Docker images | Grype / Syft / Docker CLI |
| Kubernetes | kubectl across namespaces |
| Terraform | Bedrock, Vertex AI, Azure |
| GitHub Actions | AI env vars + SDK steps |
| Python agents | 10 frameworks detected |
| Cloud providers | AWS, Azure, GCP, Databricks, Snowflake, Nebius |
| AI platforms | HuggingFace, W&B, MLflow, OpenAI |
| MCP servers | Runtime introspection via MCP SDK |
| Existing SBOMs | CycloneDX / SPDX import |
**What it outputs:**
Console, HTML dashboard, SARIF, CycloneDX 1.6, SPDX 3.0, Prometheus, OTLP, JSON, REST API
</td>
</tr>
</table>
<p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/deployment-dark.svg">
<img src="https://raw.githubusercontent.com/agent-bom/agent-bom/main/docs/images/deployment-light.svg" alt="Enterprise deployment topology" width="800" style="padding: 20px 0" />
</picture>
</p>
---
## Quick links
- **[Install](#install)** — `pip install agent-bom` or Docker
- **[Get started](#get-started)** — scan in 30 seconds
- **[AI-BOM export](#ai-bom-export)** — CycloneDX, SPDX, JSON, SARIF, HTML
- **[Remediation plan](#enterprise-remediation-plan)** — named assets, risk narratives
- **[Cloud UI](#cloud-ui)** — enterprise aggregate dashboard
- **[CI integration](#ci-integration)** — GitHub Actions + SARIF upload
- **[REST API](#rest-api)** — FastAPI on port 8422
- **[Skills](skills/)** — downloadable workflow playbooks (AI-BOM, cloud audit, OWASP, incident response)
- **[MCP Registry](src/agent_bom/mcp_registry.json)** — 109 known servers with metadata
- **[PERMISSIONS.md](PERMISSIONS.md)** — auditable trust contract
- **[Roadmap](#roadmap)** — what's coming next
---
## Get started
```bash
pip install agent-bom
# Auto-discover and scan local AI agents
agent-bom scan
# HTML dashboard with severity donut + blast radius chart
agent-bom scan -f html -o report.html && open report.html
# CI gate — fail on critical/high CVEs
agent-bom scan --fail-on-severity high -q
```
No config needed. Auto-discovers Claude Desktop, Claude Code, Cursor, Windsurf, Cline, VS Code Copilot, Continue, Zed, Cortex Code, and OpenClaw on macOS, Linux, and Windows.
---
## Install
| Mode | Command |
|------|---------|
| Core CLI | `pip install agent-bom` |
| AWS discovery | `pip install 'agent-bom[aws]'` |
| Databricks | `pip install 'agent-bom[databricks]'` |
| Snowflake | `pip install 'agent-bom[snowflake]'` |
| Nebius GPU cloud | `pip install 'agent-bom[nebius]'` |
| All cloud | `pip install 'agent-bom[cloud]'` |
| REST API | `pip install 'agent-bom[api]'` |
| Dashboard | `pip install 'agent-bom[ui]'` |
| OpenTelemetry | `pip install 'agent-bom[otel]'` |
| Docker | `docker run --rm -v ~/.config:/root/.config:ro agentbom/agent-bom scan` |
---
## Core capabilities
### CVE scanning + blast radius
```bash
agent-bom scan --enrich # OSV + NVD CVSS + EPSS + CISA KEV
agent-bom scan --image myapp:latest # Docker image (all ecosystems via Grype)
agent-bom scan --k8s --all-namespaces # Every pod in the cluster
agent-bom scan --sbom syft-output.cdx.json # Pipe in existing SBOMs
```
Every vulnerability is mapped to: **which agents** are affected, **which credentials** are exposed, **which MCP tools** an attacker can reach.
### OWASP LLM Top 10 tagging
| Code | Triggered when |
|------|---------------|
| **LLM05** | Any package CVE (always) |
| **LLM06** | Credential env var exposed alongside CVE |
| **LLM08** | Server with >5 tools + CRITICAL/HIGH CVE |
| **LLM02** | Tool with shell/exec semantics |
| **LLM07** | Tool that reads files or prompts |
| **LLM04** | AI framework + HIGH+ CVE |
### MITRE ATLAS threat mapping
Every finding is also mapped to [MITRE ATLAS](https://atlas.mitre.org/) adversarial ML techniques:
| Technique | Triggered when |
|-----------|---------------|
| **AML.T0010** | Any package CVE (always — supply chain compromise) |
| **AML.T0062** | Credentials exposed alongside vulnerability |
| **AML.T0061** | >3 tools reachable through compromised path |
| **AML.T0051** | Tools can access prompts/context (injection surface) |
| **AML.T0056** | Tools can read files (meta prompt extraction) |
| **AML.T0043** | Tools with shell/exec capability (adversarial data) |
| **AML.T0020** | AI framework + HIGH+ CVE (training data poisoning) |
| **AML.T0058** | AI framework + creds + HIGH+ (agent context poisoning) |
### NIST AI RMF compliance mapping
Every finding is also mapped to the [NIST AI Risk Management Framework](https://www.nist.gov/artificial-intelligence/ai-risk-management-framework) (AI RMF 1.0) — covering all four functions:
| Subcategory | Triggered when |
|-------------|---------------|
| **GOVERN-1.7** | Any package CVE (always — third-party component risk) |
| **MAP-3.5** | Any package CVE (always — supply chain risk assessed) |
| **GOVERN-6.1** | Shell/exec tools reachable (third-party assessment) |
| **GOVERN-6.2** | AI framework + creds + HIGH+ (contingency planning) |
| **MAP-1.6** | >3 tools reachable (interface mapping) |
| **MAP-5.2** | Data/file access tools reachable (deployment impact) |
| **MEASURE-2.5** | AI framework + HIGH+ CVE (security testing) |
| **MEASURE-2.9** | Fix available (mitigation effectiveness) |
| **MANAGE-1.3** | CISA KEV finding (documented risk response) |
| **MANAGE-2.2** | Credentials exposed (anomalous event detection) |
| **MANAGE-2.4** | AI framework + creds + HIGH+ (remediation) |
| **MANAGE-4.1** | Credentials + tools exposed (post-deployment monitoring) |
### MCP runtime introspection
Connect to live MCP servers to discover their actual runtime capabilities:
```bash
agent-bom scan --introspect # introspect all discovered servers
agent-bom scan --introspect --introspect-timeout 15 # custom timeout per server
```
Introspection is **read-only** — it only calls `tools/list` and `resources/list` (never `tools/call`). It enables:
- **Runtime tool discovery** — see actual tools exposed by running servers
- **Drift detection** — compare config-declared tools vs runtime reality
- **Hidden capability discovery** — find tools not declared in configs
- **Server enrichment** — merge runtime data into the AI-BOM inventory
Requires the MCP SDK: `pip install mcp`
### Threat framework coverage matrix
After every scan, agent-bom shows which OWASP + ATLAS + NIST AI RMF categories were triggered — and how many findings per category:
**CLI** — `print_threat_frameworks()` renders three Rich tables with bar charts:
```
┌───────────── OWASP LLM Top 10 ──────────────┐ ┌─────── NIST AI RMF 1.0 ────────┐
│ LLM05 Supply Chain Vulnerabilities 12 ████│ │ GOVERN-1.7 Third-party risk 12 ████│
│ LLM06 Sensitive Information Disclosure 4 ██ │ │ MAP-3.5 Supply chain 12 ████│
│ LLM08 Excessive Agency 2 █ │ │ MANAGE-2.2 Event detection 4 ██ │
│ LLM01 Prompt Injection — │ │ MEASURE-2.5 Security test 2 █ │
│ ... │ │ ... │
└──────────────────────────────────────────────┘ └─────────────────────────────────┘
```
**JSON** — `threat_framework_summary` section with per-category counts:
```json
{
"threat_framework_summary": {
"owasp_llm_top10": [{"code": "LLM05", "name": "Supply Chain Vulnerabilities", "findings": 12, "triggered": true}],
"mitre_atlas": [{"technique_id": "AML.T0010", "name": "ML Supply Chain Compromise", "findings": 12, "triggered": true}],
"nist_ai_rmf": [{"subcategory_id": "MAP-3.5", "name": "AI supply chain risks assessed", "findings": 12, "triggered": true}],
"total_owasp_triggered": 4,
"total_atlas_triggered": 5,
"total_nist_triggered": 6
}
}
```
**Cloud UI** — three-column threat matrix grid with hit/miss indicators and finding counts per category.
### AI-BOM export
Every scan produces a complete **AI Bill of Materials** — a structured document listing all agents, MCP servers, packages, credentials, tools, and vulnerabilities. Export in any standard format:
```bash
agent-bom scan -f cyclonedx -o ai-bom.cdx.json # CycloneDX 1.6
agent-bom scan -f spdx -o ai-bom.spdx.json # SPDX 3.0
agent-bom scan -f json -o ai-bom.json # Full AI-BOM (document_type: "AI-BOM")
agent-bom scan -f sarif -o results.sarif # GitHub Security tab
agent-bom scan -f html -o report.html # Interactive HTML dashboard
```
The JSON output includes `"document_type": "AI-BOM"` and `"spec_version": "1.0"` at the top level for programmatic identification. Console output shows an export hint panel after every scan.
### Enterprise remediation plan
Each remediation tells you exactly **what will be protected** when you fix it:
```
3. upgrade python 3.11.14 → 3.13.10
clears 2 vuln(s) • impact score: 14
agents: claude-desktop-agent (100%)
credentials: YOUTUBE_API_KEY (100%)
tools: read_file, execute_command, web_search (3 of 8 — 38%)
mitigates: LLM05 LLM06 AML.T0010 AML.T0062
⚠ if not fixed: attacker exploiting CVE-2025-1234 can reach
claude-desktop-agent → YOUTUBE_API_KEY → execute_command
```
- **Named assets** — which specific agents, credentials, and tools are at risk
- **Percentages** — what fraction of your total inventory each fix protects
- **Threat tags** — which OWASP LLM + MITRE ATLAS + NIST AI RMF categories are mitigated
- **Risk narratives** — plain-text explanation of what happens if you don't remediate
### Policy-as-code
```bash
agent-bom scan --policy policy.json --fail-on-severity high
```
```json
[
{"id": "no-unverified-high", "unverified_server": true, "severity_gte": "HIGH", "action": "fail"},
{"id": "warn-excessive-agency", "min_tools": 6, "action": "warn"},
{"id": "block-kev", "severity_gte": "CRITICAL", "action": "fail"}
]
```
### Cloud provider discovery
Discover AI agents directly from cloud provider APIs — no manual inventory files needed. Customer pays for compute; scans run in your environment with your credentials.
```bash
# AWS — Bedrock agents + Lambda + EKS + Step Functions + EC2
agent-bom scan --aws --aws-region us-east-1
agent-bom scan --aws --aws-include-lambda --aws-include-eks --aws-include-step-functions
# Snowflake — Cortex Agents, MCP Servers, Search, Snowpark, Streamlit, query history
agent-bom scan --snowflake
# Databricks — cluster libraries, model serving endpoints
agent-bom scan --databricks
# Nebius — GPU cloud K8s clusters + container services
agent-bom scan --nebius --nebius-project-id my-project
# CoreWeave — K8s-native, use the --k8s flag with your cluster context
agent-bom scan --k8s --context=coreweave-cluster --all-namespaces
# Combine with local scans
agent-bom scan --aws --databricks --snowflake --image myapp:latest --enrich
```
| Provider | What's discovered | Install |
|----------|------------------|---------|
| **AWS** | Bedrock agents, Lambda functions, EKS clusters, Step Functions workflows, EC2 instances, ECS images, SageMaker endpoints | `pip install 'agent-bom[aws]'` |
| **Snowflake** | Cortex Agents, native MCP Servers (with tool specs), Cortex Search Services, Snowpark packages, Streamlit apps, query history audit trail, custom functions/procedures | `pip install 'agent-bom[snowflake]'` |
| **Databricks** | Cluster PyPI/Maven packages, model serving endpoints | `pip install 'agent-bom[databricks]'` |
| **Azure** | AI Foundry agents, Container Apps | `pip install 'agent-bom[azure]'` |
| **GCP** | Vertex AI endpoints, Cloud Run services | `pip install 'agent-bom[gcp]'` |
| **Nebius** | Managed K8s clusters, container services + images | `pip install 'agent-bom[nebius]'` |
| **CoreWeave** | K8s-native — use `--k8s --context=coreweave-cluster` | (core CLI) |
<details>
<summary><b>AWS deep discovery flags</b></summary>
| Flag | Discovers |
|------|-----------|
| `--aws` | Bedrock agents, ECS images, SageMaker endpoints (default) |
| `--aws-include-lambda` | Standalone Lambda functions (filtered by AI runtimes) |
| `--aws-include-eks` | EKS clusters → reuses `--k8s` pod image scanning per cluster |
| `--aws-include-step-functions` | Step Functions workflows → extracts Lambda/SageMaker/Bedrock ARNs |
| `--aws-include-ec2` | EC2 instances (requires `--aws-ec2-tag KEY=VALUE` for safety) |
</details>
<details>
<summary><b>Snowflake deep discovery</b></summary>
Snowflake discovery covers the full Cortex AI stack:
- **Cortex Agents** — `SHOW AGENTS IN ACCOUNT` discovers agentic orchestration systems
- **Native MCP Servers** — `SHOW MCP SERVERS IN ACCOUNT` + `DESCRIBE MCP SERVER` parses YAML tool specs. `SYSTEM_EXECUTE_SQL` tools are flagged as **[HIGH-RISK]**
- **Query History Audit** — scans `INFORMATION_SCHEMA.QUERY_HISTORY()` for `CREATE MCP SERVER` and `CREATE AGENT` statements to catch objects created outside standard flows
- **Custom Tools** — inventories `INFORMATION_SCHEMA.FUNCTIONS` and `INFORMATION_SCHEMA.PROCEDURES` with language annotation (Python/Java/JavaScript) for attack surface analysis
- **Cortex Search + Snowpark + Streamlit** — existing discovery for search services, packages, and apps
</details>
Cloud SDKs are optional extras — install only what you need. Authentication uses each provider's standard credential chain (env vars, config files, IAM roles).
### Graph visualization
Cloud and local agents are visualized as an interactive dependency graph in the HTML dashboard. Provider nodes connect to agents, which connect to servers and packages. CVE nodes are attached to vulnerable packages with severity coloring.
Export the raw graph for use in Cytoscape, Sigma.js, or other tools:
```bash
agent-bom scan --aws -f graph -o agent-graph.json
```
### OpenClaw scanning
[OpenClaw](https://github.com/openclaw/openclaw) (214k+ stars) is the most popular open-source personal AI assistant. agent-bom auto-discovers OpenClaw configs and scans them for vulnerabilities — including 12 known CVEs (CWD injection, container escape, SSRF, XSS, secret leakage) from OpenClaw's published security advisories.
```bash
# Auto-discovers ~/.openclaw/openclaw.json and project-level .openclaw/openclaw.json
agent-bom scan
# Combine with live introspection
agent-bom scan --introspect
```
### AI-powered enrichment
Use LLMs to generate contextual risk analysis beyond template-based output. Supports 100+ LLM providers via [litellm](https://github.com/BerriAI/litellm) — OpenAI, Anthropic, Ollama (local), and more.
```bash
pip install 'agent-bom[ai-enrich]'
# Enrich with GPT-4o-mini (default)
agent-bom scan --ai-enrich
# Use a different model
agent-bom scan --ai-enrich --ai-model anthropic/claude-3-haiku-20240307
# Use local Ollama
agent-bom scan --ai-enrich --ai-model ollama/llama3
```
What `--ai-enrich` generates:
- **Risk narratives** — contextual 2-3 sentence analysis per finding (why this CVE matters in your agent's tool chain)
- **Executive summary** — one-paragraph CISO brief with risk rating and actions
- **Threat chains** — red-team-style attack chain analysis through MCP tools
### MCP Server Registry (109 servers)
Ships with a curated registry of 109 known MCP servers — including OpenClaw, ClickHouse, Figma, Prisma, Browserbase, and E2B. Each entry includes: package name + version pin, ecosystem, risk level, **risk justification** (why this server has its risk level), tool names, credential env vars, license, category, latest version, known CVEs, and source URL.
The Cloud UI provides a full **registry browser** with search, risk/category filters, and drill-down detail pages showing tools, credentials, CVEs, and risk justification for each server.
Unverified servers in your configs trigger a warning. Policy rules can block them in CI.
---
## Deployment models
| Mode | Command | Best for |
|------|---------|----------|
| Developer CLI | `agent-bom scan` | Local audit, pre-commit checks |
| Pre-install check | `agent-bom check express@4.18.2 -e npm` | Before running any MCP server |
| GitHub Action | `uses: agent-bom/agent-bom@v0.16.0` | CI/CD gate + Security tab |
| Docker | `docker run agentbom/agent-bom scan` | Isolated, reproducible scans |
| REST API | `agent-bom api` | Dashboards, SIEM, scripting |
| Dashboard | `agent-bom serve` | Team-visible security dashboard |
| Prometheus | `--push-gateway` or `--otel-endpoint` | Continuous monitoring |
| K8s CronJob | Helm chart + CronJob | Cluster-wide auditing |
---
## GitHub Action
Use agent-bom directly in your CI/CD pipeline:
```yaml
- name: AI supply chain scan
uses: agent-bom/agent-bom@v0.16.0
with:
severity-threshold: high
upload-sarif: true
```
Full options:
```yaml
- uses: agent-bom/agent-bom@v0.16.0
with:
severity-threshold: high # fail on high+ CVEs
policy: policy.json # policy-as-code gates
enrich: true # NVD CVSS + EPSS + CISA KEV
upload-sarif: true # results in GitHub Security tab
fail-on-kev: true # block actively exploited CVEs
```
Outputs: `sarif-file`, `exit-code`, `vulnerability-count` for downstream steps.
SARIF output includes OWASP LLM tags, MITRE ATLAS techniques, and NIST AI RMF subcategories in `result.properties` — visible directly in GitHub Advanced Security.
---
## AI enrichment (Ollama)
Generate risk narratives, executive summaries, and threat chain analysis using local open-source LLMs — no API keys, no cost:
```bash
# Install and start Ollama (one-time)
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2
# Scan with AI enrichment (auto-detects Ollama)
agent-bom scan --ai-enrich
```
agent-bom auto-detects Ollama at `localhost:11434`. No extra Python dependencies needed — uses httpx (already included).
For cloud LLMs (OpenAI, Anthropic, Mistral, etc.), install litellm:
```bash
pip install agent-bom[ai-enrich]
export OPENAI_API_KEY=sk-...
agent-bom scan --ai-enrich --ai-model openai/gpt-4o-mini
```
---
## REST API
```bash
pip install agent-bom[api]
agent-bom api # http://127.0.0.1:8422 → /docs for Swagger UI
```
| Endpoint | Description |
|----------|-------------|
| `GET /health` | Liveness + `X-Agent-Bom-Read-Only: true` header |
| `POST /v1/scan` | Start async scan (returns `job_id`) |
| `GET /v1/scan/{job_id}` | Poll status + results |
| `GET /v1/scan/{job_id}/stream` | SSE real-time progress |
| `GET /v1/registry` | Full MCP server registry (109 servers) |
| `GET /v1/registry/{id}` | Single registry entry |
---
## Cloud UI
The Next.js dashboard (`ui/`) provides an enterprise-grade web interface on top of the REST API:
- **Security posture dashboard** — fleet-wide severity distribution, scan source breakdown, top vulnerable packages across all scans
- **Vulnerability explorer** — group by severity, package, or agent with full-text search
- **Scan detail** — per-job blast radius table, threat framework matrix, remediation plan with impact bars, collapsible sections
- **Supply chain graph** — interactive React Flow visualization: Agent → MCP Server → Package → CVE with color-coded nodes, click-to-inspect detail panel, hover tooltips, zoom/pan, minimap, and job selector
- **Registry browser** — searchable 109-server catalog with risk/category filters, drill-down detail pages (risk justification, tools, credentials, CVEs, versions), verified badges
- **Agent discovery** — auto-discovered agents with stats bar (servers, packages, credentials, ecosystems), collapsible agent cards
- **Enterprise scan form** — bulk Docker image input (one-at-a-time, bulk paste, .txt file upload), K8s, Terraform, GitHub Actions, Python agents
- **Severity chart** — stacked bar chart with critical/high/medium/low percentage breakdown
- **Source tracking** — each finding tagged by source (MCP agents, container images, K8s pods, SBOMs)
- **Live API health check** — nav bar shows real-time backend status with version display
```bash
cd ui && npm install && npm run dev # http://localhost:3000
```
Requires the REST API backend running on port 8422.
---
## Skills
Downloadable workflow playbooks in [`skills/`](skills/) — structured instructions for common security workflows. Each skill is a self-contained markdown document with goals, steps, decision points, and output artifacts.
| Skill | What it does |
|-------|-------------|
| [**AI-BOM Generator**](skills/ai-bom-generator.md) | Full asset discovery + scan + enrich + AI Bill of Materials generation across all sources |
| [**Cloud Security Audit**](skills/cloud-security-audit.md) | Multi-cloud AI asset discovery and vulnerability assessment (AWS, Azure, GCP, Snowflake, Databricks, Nebius, CoreWeave) |
| [**OWASP LLM Assessment**](skills/owasp-llm-assessment.md) | Systematic OWASP LLM Top 10 + MITRE ATLAS threat assessment with per-category remediation |
| [**Incident Response**](skills/incident-response.md) | Given a CVE, find all affected agents, map blast radius, triage, and remediate |
| [**Pre-Deploy Gate**](skills/pre-deploy-gate.md) | CI/CD security gate — block deployments with critical CVEs or policy violations |
| [**MCP Server Review**](skills/mcp-server-review.md) | Evaluate an MCP server before adopting — registry lookup, CVE scan, tool risk analysis |
| [**Compliance Export**](skills/compliance-export.md) | Generate audit-ready CycloneDX, SPDX, SARIF with threat framework coverage reports |
---
## AI supply chain coverage
agent-bom covers the AI infrastructure landscape through multiple scanning strategies:
| Layer | How agent-bom covers it | Examples |
|-------|------------------------|----------|
| **GPU clouds** | `--k8s --context=<cluster>` | CoreWeave, Lambda Labs, Paperspace, DGX Cloud |
| **AI platforms** | Cloud provider modules | AWS Bedrock/SageMaker, Azure AI Foundry, GCP Vertex AI, Databricks, Snowflake Cortex, HuggingFace Hub, W&B, MLflow, OpenAI |
| **Container workloads** | `--image` via Grype/Syft | NVIDIA Triton, NIM, vLLM, TGI, Ollama, any OCI image |
| **K8s-native inference** | `--k8s` discovers pods | KServe, Seldon Core, Kubeflow, Ray Serve, BentoML |
| **AI frameworks** | Dependency scanning (PyPI/npm) | LangChain, LlamaIndex, AutoGen, CrewAI, PyTorch, Transformers, NeMo |
| **Vector databases** | `--image` for self-hosted | Weaviate, Qdrant, Milvus, ChromaDB, pgvector |
| **LLM providers** | API key detection + SDK scanning | OpenAI, Anthropic, Cohere, Mistral, Gemini |
| **MCP ecosystem** | Auto-discovery (10 clients) + registry (109 servers) | Claude Desktop, Cursor, Windsurf, Cline, OpenClaw |
| **IaC + CI/CD** | `--tf-dir` and `--gha` | Terraform AI resources, GitHub Actions AI workflows |
---
## agent-bom vs ToolHive
These tools solve different problems and are **complementary**.
| | agent-bom | ToolHive |
|---|---|---|
| **Purpose** | Scan + audit AI supply chain | Deploy + manage MCP servers |
| **CVE scanning** | OSV, NVD, EPSS, CISA KEV, Grype | No |
| **Blast radius** | Agents, credentials, tools | No |
| **OWASP + ATLAS + NIST** | Triple-framework tagging on every finding | No |
| **MCP server isolation** | No (scanner only) | Yes (containers + seccomp) |
| **Secret injection** | No | Yes (Vault, AWS SM) |
| **Read-only** | Yes | No (manages processes) |
**Together:** ToolHive runs your MCP servers securely. agent-bom audits whether the packages they depend on have known CVEs and what the blast radius would be.
---
## Trust & permissions
- **`--dry-run`** — shows every file and API URL that would be accessed, then exits
- **[PERMISSIONS.md](PERMISSIONS.md)** — auditable contract: what is read, what APIs are called, what is never done
- **API headers** — every response includes `X-Agent-Bom-Read-Only: true`
- **Sigstore signing** — releases v0.7.0+ signed via [cosign](https://www.sigstore.dev/)
- **Credential redaction** — only env var **names** appear in reports as `***REDACTED***`
---
## Roadmap
- [x] MITRE ATLAS adversarial ML threat mapping
- [x] SLSA provenance + SHA256 integrity verification
- [x] Threat framework coverage matrix (CLI + JSON + UI)
- [x] Enterprise remediation plan with named assets + risk narratives
- [x] Enterprise aggregate dashboard (Cloud UI)
- [x] AI-BOM export identity (CycloneDX, SPDX, JSON, SARIF)
- [x] Cloud provider discovery (AWS, Azure, GCP, Databricks, Snowflake, Nebius, CoreWeave)
- [x] Deep cloud scanning — Snowflake Cortex Agents/MCP Servers, AWS Lambda/EKS/Step Functions/EC2
- [x] Graph visualization (provider → agent → server → package → CVE)
- [x] Security skills — downloadable workflow playbooks for AI-BOM, cloud audit, OWASP, incident response
- [x] AI platform discovery — HuggingFace Hub, Weights & Biases, MLflow, OpenAI
- [x] NIST AI RMF compliance mapping (Govern, Map, Measure, Manage)
- [x] MCP runtime introspection — connect to live servers for tool/resource discovery + drift detection
- [x] OpenClaw discovery — auto-scan OpenClaw configs, 12 known CVEs from published security advisories
- [x] AI-powered enrichment — LLM-generated risk narratives, executive summaries, and threat chains via litellm
- [x] CLI posture summary — aggregate security posture panel with ecosystem breakdown and credential exposure
- [x] Interactive supply chain graph — click-to-inspect detail panel, hover tooltips, pane click dismiss
- [x] Registry enrichment — 109 servers with risk justifications, drill-down detail pages, category filters
- [x] Enterprise scan form — bulk Docker image input (paste, file upload) for fleet-scale scanning
- [x] Collapsible UI — agents, blast radius, remediation, and inventory sections collapse/expand
- [ ] Jupyter notebook AI library scanning
- [ ] ToolHive integration (`--toolhive` flag for managed server scanning)
- [ ] License compliance engine (SPDX license detection + copyleft chain analysis)
---
## Contributing
```bash
git clone https://github.com/agent-bom/agent-bom.git && cd agent-bom
pip install -e ".[dev]"
pytest && ruff check src/
```
See [CONTRIBUTING.md](CONTRIBUTING.md) | [SECURITY.md](SECURITY.md)
---
Apache 2.0 — [LICENSE](LICENSE)
<!-- Badge reference links -->
[release-img]: https://img.shields.io/pypi/v/agent-bom?style=flat&label=Latest%20version
[ci-img]: https://img.shields.io/github/actions/workflow/status/agent-bom/agent-bom/ci.yml?style=flat&logo=github&label=Build
[license-img]: https://img.shields.io/badge/License-Apache%202.0-blue?style=flat
[docker-img]: https://img.shields.io/docker/pulls/agentbom/agent-bom?style=flat&label=Docker%20pulls
[stars-img]: https://img.shields.io/github/stars/agent-bom/agent-bom?style=flat&logo=github&label=Stars
[ossf-img]: https://api.securityscorecards.dev/projects/github.com/agent-bom/agent-bom/badge
| text/markdown | null | agent-bom <security@agent-bom.dev> | null | null | Apache-2.0 | ai-bom, sbom, mcp, mcp-server, security, ai-agents, vulnerability, supply-chain, owasp, mitre-atlas, nist-ai-rmf, grype, syft, blast-radius, cve, llm-security, remediation, mcp-introspection, openclaw, ai-enrichment | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Information Technology",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Security",
"Topic :: Software Development :: Quality Assurance"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"click>=8.0",
"rich>=13.0",
"httpx>=0.28.1",
"pydantic>=2.0",
"cyclonedx-python-lib>=11.6",
"packageurl-python>=0.17",
"toml>=0.10",
"pyyaml>=6.0",
"jsonschema>=4.0",
"fastapi>=0.115; extra == \"api\"",
"uvicorn[standard]>=0.32; extra == \"api\"",
"sse-starlette>=2.1; extra == \"api\"",
"opentelemetry-api>=1.20; extra == \"otel\"",
"opentelemetry-sdk>=1.20; extra == \"otel\"",
"opentelemetry-exporter-otlp-proto-http>=1.20; extra == \"otel\"",
"streamlit>=1.35; extra == \"ui\"",
"plotly>=5.20; extra == \"ui\"",
"pandas>=2.0; extra == \"ui\"",
"boto3>=1.34; extra == \"aws\"",
"azure-identity>=1.16; extra == \"azure\"",
"azure-mgmt-resource>=23.0; extra == \"azure\"",
"azure-ai-projects>=1.0.0b3; extra == \"azure\"",
"azure-mgmt-appcontainers>=3.0; extra == \"azure\"",
"google-cloud-aiplatform>=1.48; extra == \"gcp\"",
"google-auth>=2.27; extra == \"gcp\"",
"databricks-sdk>=0.20; extra == \"databricks\"",
"snowflake-connector-python>=3.6; extra == \"snowflake\"",
"nebius>=0.1; extra == \"nebius\"",
"huggingface-hub>=0.20; extra == \"huggingface\"",
"wandb>=0.16; extra == \"wandb\"",
"mlflow>=2.10; extra == \"mlflow\"",
"openai>=1.12; extra == \"openai\"",
"litellm>=1.30; extra == \"ai-enrich\"",
"watchdog>=4.0; extra == \"watch\"",
"agent-bom[aws]; extra == \"cloud\"",
"agent-bom[azure]; extra == \"cloud\"",
"agent-bom[gcp]; extra == \"cloud\"",
"agent-bom[databricks]; extra == \"cloud\"",
"agent-bom[snowflake]; extra == \"cloud\"",
"agent-bom[nebius]; extra == \"cloud\"",
"agent-bom[huggingface]; extra == \"cloud\"",
"agent-bom[wandb]; extra == \"cloud\"",
"agent-bom[mlflow]; extra == \"cloud\"",
"agent-bom[openai]; extra == \"cloud\"",
"pytest>=7.0; extra == \"dev\"",
"pytest-asyncio>=0.21; extra == \"dev\"",
"ruff>=0.4; extra == \"dev\"",
"mypy>=1.0; extra == \"dev\"",
"pip-audit>=2.10; extra == \"dev\"",
"bandit>=1.9; extra == \"dev\"",
"safety>=3.7; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/agent-bom/agent-bom",
"Repository, https://github.com/agent-bom/agent-bom",
"Issues, https://github.com/agent-bom/agent-bom/issues",
"Changelog, https://github.com/agent-bom/agent-bom/releases",
"Documentation, https://github.com/agent-bom/agent-bom#readme",
"Security Policy, https://github.com/agent-bom/agent-bom/blob/main/SECURITY.md",
"Trust & Permissions, https://github.com/agent-bom/agent-bom/blob/main/PERMISSIONS.md"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:44:30.588706 | agent_bom-0.17.0.tar.gz | 244,934 | d6/b6/7a476ec23577504a18cd145e1073b0679162bebaf57bfd71393fc77f7d00/agent_bom-0.17.0.tar.gz | source | sdist | null | false | a6db9036c6ec53f1bdc3df978fa0f421 | cbe9c6b56093862bd4144be85bf92560746679ba09f0b15170f704db40a051e7 | d6b67a476ec23577504a18cd145e1073b0679162bebaf57bfd71393fc77f7d00 | null | [
"LICENSE"
] | 235 |
2.1 | PyQUDA | 0.10.45 | Python wrapper for QUDA written in Cython | # PyQUDA
Python wrapper for [QUDA](https://github.com/lattice/quda) written in Cython.
This project aims to benefit from the optimized linear algebra library [CuPy](https://cupy.dev/) in Python based on CUDA. CuPy and QUDA will allow us to perform most lattice QCD research operations with high performance. [PyTorch](https://pytorch.org/) is an alternative option.
This project is based on the latest QUDA `develop` branch. PyQUDA should be compatible with any commit of QUDA after https://github.com/lattice/quda/pull/1489, but leave some features disabled.
## Feature
- Multi-GPU supported
- with [MPI for Python](https://mpi4py.readthedocs.io/en/stable/) package
- File I/O
- Read gauge and propagator in Chroma format (with checksum)
- Read gauge and propagator in MILC format (with checksum)
- Read/write gauge and propagator in KYU format
- Read/write gauge and propagator in XQCD format
- Read/write gauge and propagator in NPY format (numpy)
- Quark propagator
- Isotropic/anisotropic Wilson fermion action with multigrid support
- Isotropic/anisotropic Clover fermion action with multigrid support
- Isotropic HISQ fermion action
- HMC
- Isotropic gauge action
- 1-flavor isotropic clover fermion action
- 2-flavor isotropic clover fermion action
- N-flavor isotropic HISQ fermion action
- Gauge fixing
- Rotation field with over-relaxation method (waiting for QUDA merge)
- Gauge smearing
- 3D/4D APE smearing
- 3D/4D stout smearing
- 3D/4D HYP smearing
- Fermion smearing
- Gaussian smearing
- Gradient flow
- Wilson flow
- Symanzik flow
## Installation
### Install from PyPI
Assuming the QUDA installation path is `/path/to/quda/build/usqcd`
```bash
export QUDA_PATH=/path/to/quda/build/usqcd
python3 -m pip install pyquda pyquda-utils
```
### Install from source
Refer to https://github.com/CLQCD/PyQUDA/wiki/Installation for detailed instructions to install PyQUDA from the source.
## Benchmark
Refer to https://github.com/CLQCD/PyQUDA/wiki/Benchmark for detailed instructions to run the PyQUDA benchmark.
## Documentation (draft)
https://github.com/CLQCD/PyQUDA/wiki/Documentation
## Development
We recommend building PyQUDA using in-place mode instead of installing PyQUDA for development.
```bash
git clone --recursive https://github.com/CLQCD/PyQUDA.git
cd PyQUDA
ln -s pyquda_core/pyquda pyquda
cd pyquda_core
export QUDA_PATH=/path/to/quda/build/usqcd
python3 setup.py build_ext --inplace
```
Now you can modify Python files in the project and immediately get the new result by running scripts. Adding the root directory to `sys.path` is needed if you are running scripts from other directories.
## Maintenance
Function definitions (mainly in `quda.in.pxd` and `quda.in.pyx`) and most docstrings (mainly in `pyquda.pyi` and `enum_quda.in.py`) should be manually updated as they cannot be autogenerated now. This also means PyQUDA should work well with future versions if the API remains unchanged.
| text/markdown | null | SaltyChiang <SaltyChiang@users.noreply.github.com> | null | SaltyChiang <SaltyChiang@users.noreply.github.com> | MIT License
Copyright (c) 2022-2024 PyQUDA Developers
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.
| lattice-gauge-theory, lattice-field-theory, lattice-qcd, hep-lat | [
"Development Status :: 2 - Pre-Alpha",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Cython",
"Operating System :: POSIX :: Linux",
"Environment :: GPU",
"Environment :: GPU :: NVIDIA CUDA",
"Topic :: Scientific/Engineering :: Physics"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"mpi4py",
"numpy"
] | [] | [] | [] | [
"Homepage, https://github.com/CLQCD/PyQUDA",
"Documentation, https://github.com/CLQCD/PyQUDA/wiki/Documentation",
"Repository, https://github.com/CLQCD/PyQUDA.git",
"Issues, https://github.com/CLQCD/PyQUDA/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:43:51.669233 | pyquda-0.10.45.tar.gz | 173,414 | f1/b6/12908e4be367f4663a20d9407fc4716111e6ac7a308556f3adb80f48a35e/pyquda-0.10.45.tar.gz | source | sdist | null | false | 7802cfecd2b3159db4d678db8db54116 | 93d34d16d19889b0aef69edd59e7c59dbb4d4debd6db0f22e330cbb21bf7062c | f1b612908e4be367f4663a20d9407fc4716111e6ac7a308556f3adb80f48a35e | null | [] | 0 |
2.1 | sparkstart | 1.0.1 | Create a new project in seconds, not hours. sparkstart handles all the boring setup so you can start coding immediately. | # sparkstart ⚡
**Create a new project in seconds, not hours.**
`sparkstart` handles all the boring setup so you can start coding immediately. No more copy-pasting boilerplate, no more manual configuration—just run one command and you're ready to go.
[](https://github.com/majorlongval/sparkstart/actions)
[](https://www.python.org/downloads/)
[](LICENSE)
## ✨ What It Does
1. **🚀 Instant Setup** — Creates project structure, git repo, and starter code in seconds
2. **🐳 Dev Containers** — Optional Docker environments with pre-configured tools
3. **🎓 Educational Projects** — Learn new languages with guided game tutorials
4. **🛠️ Code Quality Tools** — Pre-commit hooks, linters, and formatters built-in
5. **☁️ GitHub Integration** — Auto-create and push repositories
6. **📚 Smart Help System** — Built-in guides and tutorials for every project
## 🚀 Quick Start
```bash
# Install
pip install sparkstart
# Create a project (interactive wizard)
sparkstart new
# Or use direct mode with flags
sparkstart new my-awesome-game --lang python --devcontainer --tools
```
That's it! Your project is ready to code.
## 📋 Supported Languages
| Language | Features |
|----------|----------|
| **Python** | Poetry/pip, venv, pytest, best practices |
| **Rust** | Cargo, clippy, rustfmt, testing setup |
| **JavaScript** | npm/Node.js, ESLint, Prettier, testing framework |
| **C++** | CMake, Conan, build system, googletest |
## 🎯 Usage
### Interactive Wizard (Recommended)
```bash
sparkstart new
```
Guides you through:
- Project name
- Programming language
- Dev container setup (Docker)
- Code quality tools (formatters, linters, pre-commit)
- Educational project option (learn by building games)
- GitHub push
### Direct Mode with Flags
```bash
# Python project with all features
sparkstart new my-app --lang python --devcontainer --tools --github
# Rust project for learning
sparkstart new learning-rust --lang rust --tutorial
# Quick JavaScript project
sparkstart new web-app --lang javascript --tools
# C++ with Docker environment
sparkstart new cpp-project --lang cpp --devcontainer
```
### Available Options
```
--lang, -l LANG Language: python, rust, javascript, cpp
--template TEMPLATE Template: pygame (python only)
--tutorial, -t Educational project with tests and guides
--devcontainer, -d Docker dev container with direnv + compose
--tools Formatters, linters, pre-commit hooks
--github Create and push to GitHub repository
--help, -h Show help information
```
### Commands
```bash
sparkstart new [NAME] Create new project
sparkstart help Show comprehensive help
sparkstart version Show version
```
## 🎁 What's Included
### Every Project Gets:
✅ **Project Structure**
- Language-specific folder layout
- Working starter code ("Hello World")
- README.md and .gitignore
- Git repository (pre-initialized)
✅ **Documentation**
- GETTING_STARTED.md (language-specific setup guide)
- Inline code comments
- Example code patterns
✅ **Testing Setup**
- Test files and examples
- Pre-configured test runner
- Sample test cases
### With `--devcontainer`:
🐳 **Docker Development Environment**
- `.devcontainer/` with Dockerfile
- `docker-compose.yaml` for orchestration
- `.envrc` for automatic environment setup (direnv)
- Pre-installed tools and dependencies
- Reproducible development across machines
### With `--tools`:
🛠️ **Code Quality Tools**
- **Formatters**: black (Python), prettier (JS), rustfmt (Rust), clang-format (C++)
- **Linters**: ruff (Python), eslint (JS), clippy (Rust)
- **Pre-commit hooks**: Automatic code checking before commits
- **.editorconfig**: Editor consistency across team
### With `--tutorial`:
🎓 **Educational Game Project**
- Complete working game (Pygame for Python)
- Tutorial and learning resources
- Exercises to practice concepts
- Tests to verify your progress
### With `--github`:
☁️ **GitHub Integration**
- Automatic repository creation
- Secure token handling (saved locally, never committed)
- Initial commit and push
- Ready for collaboration
## 💡 Pro Tips
- **Use `--devcontainer`** for consistent development across team and machines
- **Use `--tools`** to enforce code quality from the start
- **Use `--tutorial`** to learn a new language with guided exercises
- **Check `GETTING_STARTED.md`** in your new project for language-specific commands
- **GitHub token** is saved to `.projinit.env` (never committed to git)
## 🔧 Requirements
### Minimum
- **Python** 3.8+ → [Download](https://www.python.org/downloads/)
- **Git** → [Download](https://git-scm.com/downloads)
### Optional
- **Docker** (for `--devcontainer`) → [Download](https://www.docker.com/get-started)
- **Language runtime** for chosen language:
- Python: Built-in ✅
- Rust: [rustup.rs](https://rustup.rs/)
- Node.js: [nodejs.org](https://nodejs.org/)
- C++: gcc/clang (or use `--devcontainer`)
## 📦 Installation
### From PyPI (Recommended)
```bash
pip install sparkstart
```
### From Source
```bash
git clone https://github.com/majorlongval/sparkstart
cd sparkstart
pip install -e .
```
### Verify Installation
```bash
sparkstart version
```
## 🎮 Examples
### Python Game Project
```bash
sparkstart new my-game --lang python --template pygame --tutorial
cd my-game
cat GETTING_STARTED.md # See setup instructions
```
### Rust Project with DevContainer
```bash
sparkstart new learn-rust --lang rust --devcontainer --tutorial
cd learn-rust
direnv allow # Auto-activate environment
docker compose up -d # Start dev container
docker compose exec dev cargo test # Run tests in container
```
### Production JavaScript Project
```bash
sparkstart new production-app --lang javascript --tools --github --devcontainer
cd production-app
npm install
npm test
git push
```
### C++ Academic Project
```bash
sparkstart new algorithms --lang cpp --tutorial --tools
cd algorithms
mkdir build && cd build && cmake .. && make
./test_algorithms
```
## 🛠️ Shell Completion
### Bash
Add to `~/.bashrc`:
```bash
eval "$(sparkstart --bash-completion)"
```
### Zsh
Add to `~/.zshrc`:
```bash
eval "$(sparkstart --zsh-completion)"
```
Then run:
```bash
source ~/.bashrc # or ~/.zshrc
```
Now you get autocomplete for:
- Commands (new, help, version)
- Languages (python, rust, javascript, cpp)
- Templates (pygame)
- All flags and options
## 📚 Documentation
- **[Getting Started](./docs/GETTING_STARTED.md)** — Detailed setup guide
- **[Contributing Guide](./CONTRIBUTING.md)** — How to contribute
- **[Changelog](./CHANGELOG.md)** — Version history and updates
- **[Architecture](./docs/architecture.md)** — How sparkstart works
## 🐛 Troubleshooting
### Missing Docker?
```bash
# macOS
brew install docker
# Linux (Ubuntu/Debian)
sudo apt install docker.io
# Windows
# Download Docker Desktop: https://www.docker.com/get-started
```
### Missing Git?
```bash
# macOS
brew install git
# Linux (Ubuntu/Debian)
sudo apt install git
# Windows
# Download: https://git-scm.com/
```
### Project Already Exists?
Use a different name:
```bash
sparkstart new my-project-v2
```
Or remove the existing directory:
```bash
rm -rf my-project
sparkstart new my-project
```
### GitHub Token Issues?
1. The token is saved to `.projinit.env` (never committed)
2. To regenerate: Remove `.projinit.env` and re-run with `--github`
3. Personal access token docs: [GitHub Docs](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token)
## 🤝 Contributing
We'd love your help! See [CONTRIBUTING.md](./CONTRIBUTING.md) for:
- How to set up development environment
- Running tests
- Submitting pull requests
- Code style guidelines
## 📝 License
MIT License — See [LICENSE](./LICENSE) for details
## 🎉 Quick Facts
- ⚡ **Fast** — Creates projects in seconds
- 🔒 **Secure** — GitHub tokens never committed
- 🎯 **Focused** — Does one thing well
- 📚 **Educational** — Learn new languages faster
- 🛠️ **Professional** — Production-ready code quality
- 🐳 **Docker-Ready** — Dev containers included
## 📞 Support
- **Questions?** Check the [help system](README.md#-documentation)
- **Found a bug?** [Open an issue](https://github.com/majorlongval/sparkstart/issues)
- **Have an idea?** [Create a discussion](https://github.com/majorlongval/sparkstart/discussions)
---
**Ready to start?** Run `sparkstart new` and create your first project! 🚀
| text/markdown | null | Jordan Longval <majorlongval@gmail.com> | null | null | MIT | project, scaffolding, generator, quickstart, cli, python, rust, javascript, cpp, template, devops, docker | [
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: MacOS",
"Operating System :: POSIX",
"Operating System :: POSIX :: Linux",
"Operating System :: Microsoft :: Windows",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Utilities"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"typer",
"requests",
"python-dotenv",
"pytest; extra == \"test\"",
"pytest-cov; extra == \"test\"",
"pytest-xdist; extra == \"test\"",
"black; extra == \"dev\"",
"ruff; extra == \"dev\"",
"mypy; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"build; extra == \"build\"",
"twine; extra == \"build\"",
"wheel; extra == \"build\""
] | [] | [] | [] | [
"Homepage, https://github.com/majorlongval/sparkstart",
"Repository, https://github.com/majorlongval/sparkstart",
"Documentation, https://github.com/majorlongval/sparkstart#readme",
"Issues, https://github.com/majorlongval/sparkstart/issues",
"Changelog, https://github.com/majorlongval/sparkstart/blob/main/CHANGELOG.md"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-21T04:42:26.802239 | sparkstart-1.0.1.tar.gz | 74,235 | 29/0d/0c8dc8ad0b514528eee0a6dfa6c84f4253d17629274993822963a4b1fa4b/sparkstart-1.0.1.tar.gz | source | sdist | null | false | fc38dd25cbbe47946c00eb54889c284a | 6f34d12f015979d0b2938d35453ae6d03656c7fcd49284fe369ce0c21c63aa3c | 290d0c8dc8ad0b514528eee0a6dfa6c84f4253d17629274993822963a4b1fa4b | null | [] | 241 |
2.4 | kuru-sdk-py | 0.1.7 | Add your description here | # Kuru Market Maker SDK (Python)
A Python SDK for building market maker bots on the [Kuru](https://kuru.io) orderbook protocol.
## Features
- **Batch Cancel/Replace** - Atomically cancel and place orders in a single transaction via the MM Entrypoint
- **Order Lifecycle Tracking** - Track orders from creation through fills and cancellations via on-chain events
- **Real-time Orderbook Feed** - WebSocket client for live best bid/ask with auto-reconnection
- **Margin Account Integration** - Deposit, withdraw, and query margin balances
- **EIP-7702 Authorization** - Automatic MM Entrypoint authorization for your EOA
- **Gas Optimization** - EIP-2930 access list support to reduce gas costs
## Installation
```bash
pip install kuru-sdk-py
# or
uv add kuru-sdk-py
```
Create a `.env` file:
```bash
# Required
PRIVATE_KEY=0x...
MARKET_ADDRESS=0x...
# Optional endpoints (defaults exist)
RPC_URL=https://rpc.monad.xyz/
RPC_WS_URL=wss://rpc.monad.xyz/
KURU_WS_URL=wss://ws.kuru.io/
KURU_API_URL=https://api.kuru.io/
# Optional WebSocket behavior
KURU_RPC_LOGS_SUBSCRIPTION=monadLogs # Set to logs for commited-state streaming
# Optional trading defaults
KURU_POST_ONLY=true
KURU_AUTO_APPROVE=true
KURU_USE_ACCESS_LIST=true
```
## Example
You can find an example market making bot [here](https://github.com/Kuru-Labs/mm-example) — a skew-based quoting strategy with event-driven order tracking.
## Core Concepts
Kuru market making interacts with three on-chain components:
- **Orderbook contract** (`MARKET_ADDRESS`): holds the limit orderbook and emits `OrderCreated`, `OrdersCanceled`, and `Trade` events.
- **Margin account contract**: holds your trading balances. Orders consume margin balances, not wallet balances.
- **MM Entrypoint (EIP-7702 delegation)**: your EOA is authorized to delegate to the MM Entrypoint contract, enabling batch cancel and place operations in a single transaction.
The SDK provides:
- `KuruClient`: the main facade for execution, event listeners, and orderbook streaming.
- `User`: deposits/withdrawals, approvals, and EIP-7702 authorization.
- `Order`: your local representation of a limit order or cancel.
## Market Making Guide
A typical market making bot has four concurrent loops:
1. **Market data ingestion** - subscribe to the orderbook WebSocket for best bid/ask.
2. **Quote generation** - decide where to quote (spreads, levels, sizes) based on your model + inventory.
3. **Execution** - atomically cancel + place quotes using `client.place_orders()`.
4. **Order lifecycle & fills** - listen to on-chain events to track placements, fills, and cancellations.
The SDK handles (1), (3), and (4). You supply (2).
### Step 1 - Create a client
```python
import os
from dotenv import load_dotenv
from kuru_sdk_py.client import KuruClient
from kuru_sdk_py.configs import ConfigManager
load_dotenv()
configs = ConfigManager.load_all_configs(
market_address=os.environ["MARKET_ADDRESS"],
fetch_from_chain=True,
)
client = await KuruClient.create(**configs)
```
`fetch_from_chain=True` reads the market's on-chain params and sets `price_precision`, `size_precision`, `tick_size`, and token addresses/decimals/symbols automatically.
### Step 2 - Fund margin
Orders are backed by margin balances. Deposit base and/or quote before quoting:
```python
await client.user.deposit_base(10.0, auto_approve=True)
await client.user.deposit_quote(500.0, auto_approve=True)
margin_base_wei, margin_quote_wei = await client.user.get_margin_balances()
```
If you quote both sides, keep both base and quote margin funded; otherwise your orders will revert.
### Step 3 - Start the client
`client.start()` performs EIP-7702 authorization and connects to the RPC WebSocket for on-chain event tracking.
Set an order callback to track your order lifecycle:
```python
from kuru_sdk_py.manager.order import Order, OrderStatus
active_cloids: set[str] = set()
async def on_order(order: Order) -> None:
if order.status in (OrderStatus.ORDER_PLACED, OrderStatus.ORDER_PARTIALLY_FILLED):
active_cloids.add(order.cloid)
if order.status in (OrderStatus.ORDER_CANCELLED, OrderStatus.ORDER_FULLY_FILLED):
active_cloids.discard(order.cloid)
client.set_order_callback(on_order)
await client.start()
```
Alternatively, read from `client.orders_manager.processed_orders_queue` instead of using callbacks.
### Step 4 - Subscribe to real-time orderbook data
```python
from kuru_sdk_py.feed.orderbook_ws import KuruFrontendOrderbookClient, FrontendOrderbookUpdate
best_bid: float | None = None
best_ask: float | None = None
async def on_orderbook(update: FrontendOrderbookUpdate) -> None:
global best_bid, best_ask
if update.b:
best_bid = update.b[0][0]
if update.a:
best_ask = update.a[0][0]
client.set_orderbook_callback(on_orderbook)
await client.subscribe_to_orderbook()
```
**WebSocket price/size units:** Prices and sizes in `FrontendOrderbookUpdate` are pre-normalized to human-readable floats. No manual conversion is needed.
### Step 5 - Cancel and place quotes
Build a grid of orders, cancel stale ones, and send them in a single batch transaction:
```python
import time
from kuru_sdk_py.manager.order import Order, OrderType, OrderSide
def build_grid(mid: float) -> list[Order]:
ts = int(time.time() * 1000)
spread_bps = 10 # 0.10%
size = 5.0
bid = mid * (1 - spread_bps / 10_000)
ask = mid * (1 + spread_bps / 10_000)
return [
Order(cloid=f"bid-{ts}", order_type=OrderType.LIMIT, side=OrderSide.BUY, price=bid, size=size),
Order(cloid=f"ask-{ts}", order_type=OrderType.LIMIT, side=OrderSide.SELL, price=ask, size=size),
]
orders = []
orders += [Order(cloid=c, order_type=OrderType.CANCEL) for c in active_cloids]
orders += build_grid(mid=100.0)
txhash = await client.place_orders(
orders,
post_only=True, # maker-only (recommended)
price_rounding="default", # buy rounds down, sell rounds up
)
```
#### Cancel all orders
To cancel all active orders for the market (useful for circuit breakers or graceful shutdown):
```python
await client.cancel_all_active_orders_for_market()
```
This cancels every order you have on the book for this market in a single transaction, regardless of whether you're tracking them locally.
#### Tick size and rounding
On-chain prices must align to `market_config.tick_size`. When you pass float prices to `place_orders()`, the SDK converts them to integers using `price_precision` and then rounds to tick size.
`price_rounding` options:
- `"default"` - round **down** for buys and **up** for sells (recommended)
- `"down"` - round down for both sides
- `"up"` - round up for both sides
- `"none"` - no tick rounding (only if you already quantize yourself)
### Step 6 - React to fills and inventory
The SDK delivers order status updates via the callback or queue:
- `ORDER_PLACED` - confirmed on book
- `ORDER_PARTIALLY_FILLED` - size reduced
- `ORDER_FULLY_FILLED` - size goes to 0
- `ORDER_CANCELLED` - removed from book
Typical market maker reactions:
- Record fills and PnL
- Adjust inventory targets
- Skew spreads based on inventory (long base -> tighten asks, widen bids)
- Refresh quotes more aggressively after fills
Compute inventory from margin balances:
```python
margin_base_wei, margin_quote_wei = await client.user.get_margin_balances()
base = margin_base_wei / (10 ** market_config.base_token_decimals)
quote = margin_quote_wei / (10 ** market_config.quote_token_decimals)
```
## Order Types
### Limit Orders
```python
from kuru_sdk_py.manager.order import Order, OrderType, OrderSide
Order(
cloid="my-bid-1",
order_type=OrderType.LIMIT,
side=OrderSide.BUY,
price=100.0,
size=1.0,
)
```
### Market Orders
```python
await client.place_market_buy(quote_amount=100.0, min_amount_out=0.9)
await client.place_market_sell(size=1.0, min_amount_out=90.0)
```
### Cancel Orders
```python
Order(cloid="my-bid-1", order_type=OrderType.CANCEL)
```
### Batch Updates
```python
orders = [
Order(cloid="bid-1", order_type=OrderType.LIMIT, side=OrderSide.BUY, price=99.0, size=1.0),
Order(cloid="ask-1", order_type=OrderType.LIMIT, side=OrderSide.SELL, price=101.0, size=1.0),
Order(cloid="old-bid", order_type=OrderType.CANCEL),
]
txhash = await client.place_orders(orders, post_only=True)
```
## WebSocket Feeds
The SDK provides two standalone WebSocket clients for real-time orderbook data. Both can be used independently of `KuruClient` — no wallet or private key required.
### `KuruFrontendOrderbookClient` (orderbook_ws)
Connects to Kuru's frontend orderbook WebSocket. Delivers a **full L2 snapshot** on connect, then incremental updates with events (trades, order placements, cancellations).
- Prices and sizes are pre-normalized to human-readable floats.
- Each update may contain `b` (bids) and `a` (asks) with all current levels at that price, plus an `events` list describing what changed.
```python
import asyncio
from kuru_sdk_py.configs import ConfigManager
from kuru_sdk_py.feed.orderbook_ws import KuruFrontendOrderbookClient, FrontendOrderbookUpdate
market_config = ConfigManager.load_market_config(market_address="0x...", fetch_from_chain=True)
connection_config = ConfigManager.load_connection_config()
update_queue: asyncio.Queue[FrontendOrderbookUpdate] = asyncio.Queue()
client = KuruFrontendOrderbookClient(
ws_url=connection_config.kuru_ws_url,
market_address=market_config.market_address,
update_queue=update_queue,
size_precision=market_config.size_precision,
)
async with client:
while True:
update = await update_queue.get()
if update.b:
best_bid = update.b[0][0] # Already a float
if update.a:
best_ask = update.a[0][0] # Already a float
```
You can also subscribe via `KuruClient` instead of using the client directly:
```python
client.set_orderbook_callback(on_orderbook)
await client.subscribe_to_orderbook()
```
---
### `ExchangeWebsocketClient` (exchange_ws)
Connects to the exchange WebSocket in **Binance-compatible format**. Delivers incremental depth updates (`depthUpdate`) and optionally Monad-enhanced updates with blockchain state (`monadDepthUpdate`).
- Messages are binary (JSON serialized to bytes).
- Prices and sizes are pre-normalized to human-readable floats.
- `MonadDepthUpdate` includes `blockNumber`, `blockId`, and `state` (`"proposed"` | `"committed"` | `"finalized"`).
**Key difference from `orderbook_ws`:** The exchange WebSocket sends **incremental delta updates only** — `b` and `a` contain only the price levels that changed, not the full book. A size of `0.0` means that level was removed. You must maintain a local orderbook and apply each delta.
```python
import asyncio
from kuru_sdk_py.configs import ConfigManager
from kuru_sdk_py.feed.exchange_ws import ExchangeWebsocketClient, DepthUpdate, MonadDepthUpdate
market_config = ConfigManager.load_market_config(market_address="0x...", fetch_from_chain=True)
connection_config = ConfigManager.load_connection_config()
update_queue = asyncio.Queue()
client = ExchangeWebsocketClient(
ws_url=connection_config.exchange_ws_url,
market_config=market_config,
update_queue=update_queue,
)
# Local orderbook — must be seeded and maintained manually
orderbook = {"bids": {}, "asks": {}}
async with client:
while True:
update = await update_queue.get()
# Apply bid deltas (prices and sizes are pre-normalized floats)
for price, size in update.b:
if size == 0.0:
orderbook["bids"].pop(price, None) # Level removed
else:
orderbook["bids"][price] = size # Level added or updated
# Apply ask deltas
for price, size in update.a:
if size == 0.0:
orderbook["asks"].pop(price, None) # Level removed
else:
orderbook["asks"][price] = size # Level added or updated
# For MonadDepthUpdate, blockchain state is also available:
if isinstance(update, MonadDepthUpdate):
print(f"Block {update.blockNumber} ({update.state})")
```
---
### Choosing between the two
| | `KuruFrontendOrderbookClient` | `ExchangeWebsocketClient` |
|---|---|---|
| Initial snapshot | Full L2 book on connect | None (delta-only) |
| Update style | Full levels at changed prices + events | Incremental deltas |
| Local book required | No | Yes |
| Event detail (trades, orders) | Yes (`events` field) | No |
| Blockchain state | No | Yes (monad variant) |
| Message format | Text JSON | Binary JSON |
---
## Configuration
The SDK uses `ConfigManager` to load configuration from environment variables with sensible defaults. See the [Environment Variables](#installation) section above for the full list.
For advanced configuration (custom timeouts, reconnection behavior, gas settings, presets), see `examples/config_examples.py`.
```python
from kuru_sdk_py.configs import ConfigManager, ConfigPresets
# One-liner: load everything from env vars
configs = ConfigManager.load_all_configs(
market_address=os.environ["MARKET_ADDRESS"],
fetch_from_chain=True,
)
client = await KuruClient.create(**configs)
# Or use presets for common scenarios
preset = ConfigPresets.conservative() # Longer timeouts, more retries (production)
preset = ConfigPresets.aggressive() # Shorter timeouts, fewer retries (HFT)
preset = ConfigPresets.testnet() # Optimized for slower testnets
```
## Production Guidance
### Use a dedicated RPC
The default public endpoints can be rate-limited. For production, use a dedicated RPC provider via `RPC_URL` and `RPC_WS_URL`.
### Quote cadence and gas
Batch cancel/replace every second is expensive on-chain. Common approaches:
- Update only when mid price moves beyond a threshold
- Update at a slower cadence (e.g., 5-15s) unless volatility spikes
- Use fewer levels or smaller grids
- Enable EIP-2930 access list optimization (`KURU_USE_ACCESS_LIST=true`)
If you see **"out of gas" or "gas too low" transaction failures**, increase the gas buffer multiplier:
```bash
KURU_GAS_BUFFER_MULTIPLIER=1.3 # default is 1.2; try 1.3 to 1.5
```
### Safety checks
- **Stale data guard** - don't quote if your market data feed is older than N milliseconds
- **Min/max size** - ensure order sizes meet market constraints (or the tx will revert)
- **Balance guard** - ensure margin balances can support your outstanding orders
- **Circuit breakers** - stop quoting on repeated failures, disconnects, or extreme spreads. Use `await client.cancel_all_active_orders_for_market()` to cancel all outstanding orders when the circuit breaker triggers
## Examples
```bash
# End-to-end market making bot (requires PRIVATE_KEY + MARKET_ADDRESS)
PYTHONPATH=. uv run python examples/simple_market_making_bot.py
# Read-only frontend orderbook stream (full snapshots, no wallet required)
PYTHONPATH=. uv run python examples/get_orderbook_ws.py
# Read-only exchange orderbook stream (Binance-compatible delta updates, no wallet required)
PYTHONPATH=. uv run python examples/get_exchange_orderbook_ws.py
# Repeated batch placement + cancels
PYTHONPATH=. uv run python examples/place_many_orders.py
```
## Testing
```bash
uv run pytest tests/ -v
```
## Requirements
- Python >= 3.10
- Dependencies managed via uv (see `pyproject.toml`)
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"aiocache>=0.12.3",
"aiohttp>=3.9.0",
"asyncio>=4.0.0",
"loguru>=0.7.3",
"pytest>=9.0.2",
"pytest-asyncio>=1.3.0",
"python-dotenv>=1.0.0",
"web3>=7.14.0",
"websockets>=15.0.1"
] | [] | [] | [] | [] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-21T04:42:26.120538 | kuru_sdk_py-0.1.7.tar.gz | 136,140 | 8f/f2/1325a09ce531102a36af2e131a7c4a4bb143217210eb6b7caae23cc10ad4/kuru_sdk_py-0.1.7.tar.gz | source | sdist | null | false | b73e8a65d2f07e9f808788b79096f3e5 | 7ecf275fb6ce173ffa76327ad8703710a78db68656e16dd303248095292e1b09 | 8ff21325a09ce531102a36af2e131a7c4a4bb143217210eb6b7caae23cc10ad4 | null | [] | 236 |
2.4 | rustyzipper | 1.1.1 | A high-performance, secure file compression library with password protection | # rustyzipper
[](https://github.com/johnnywale/rustyzip/actions/workflows/ci.yml)
[](https://pypi.org/project/rustyzipper/)
[](https://pypi.org/project/rustyzipper/)
[](LICENSE-MIT)
A high-performance, secure file compression library with password protection, written in Rust with Python bindings.
**rustyzipper** is a modern, actively maintained replacement for [pyminizip](https://github.com/smihica/pyminizip), addressing critical security vulnerabilities while more encryption options.
## Why rustyzipper?
### Problems with pyminizip:
- Abandoned (last update years ago)
- Security vulnerabilities (CVE-2022-37434)
- Outdated zlib version
- No AES-256 support
### rustyzipper advantages:
- **Actively maintained** with regular updates
- **No known security vulnerabilities**
- **Modern zlib** (latest version)
- **AES-256 encryption** for sensitive data
- **Drop-in pyminizip replacement**
- **Windows Explorer compatible** (ZipCrypto option)
- **Zero Python dependencies** (fully self-contained)
## Installation
```bash
pip install rustyzipper
```
## Quick Start
### Modern API (Recommended)
```python
from rustyzipper import compress_file, decompress_file, EncryptionMethod, SecurityPolicy
# Secure compression with AES-256 (recommended for sensitive data)
compress_file("document.pdf", "secure.zip", password="MySecureP@ssw0rd")
# Windows Explorer compatible (weak security, use only for non-sensitive files)
compress_file(
"public.pdf",
"compatible.zip",
password="simple123",
encryption=EncryptionMethod.ZIPCRYPTO,
suppress_warning=True
)
# Decompress with default security (protected against ZIP bombs)
decompress_file("secure.zip", "extracted/", password="MySecureP@ssw0rd")
# Decompress with custom security policy
policy = SecurityPolicy(max_size="10GB", max_ratio=1000)
decompress_file("large.zip", "extracted/", policy=policy)
# Decompress with unlimited policy (for trusted archives only)
decompress_file("trusted.zip", "out/", policy=SecurityPolicy.unlimited())
```
### pyminizip Compatibility (No Code Changes Required)
```python
# Change this line:
# import pyminizip
# To this:
from rustyzipper.compat import pyminizip
# Rest of your code works as-is!
pyminizip.compress("file.txt", None, "output.zip", "password", 5)
pyminizip.uncompress("output.zip", "password", "extracted/", 0)
```
## Features
### Encryption Methods
| Method | Security | Compatibility | Use Case |
|--------|----------|---------------|----------|
| **AES-256** | Strong | 7-Zip, WinRAR, WinZip | Sensitive data |
| **ZipCrypto** | Weak | Windows Explorer, All tools | Maximum compatibility |
| **None** | None | All tools | Non-sensitive data |
### Compression Levels
```python
from rustyzipper import CompressionLevel
CompressionLevel.STORE # No compression (fastest)
CompressionLevel.FAST # Fast compression
CompressionLevel.DEFAULT # Balanced (recommended)
CompressionLevel.BEST # Maximum compression (slowest)
```
## API Reference
### compress_file
```python
compress_file(
input_path: str,
output_path: str,
password: str | None = None,
encryption: EncryptionMethod = EncryptionMethod.AES256,
compression_level: CompressionLevel = CompressionLevel.DEFAULT,
suppress_warning: bool = False
) -> None
```
### compress_files
```python
compress_files(
input_paths: list[str],
output_path: str,
password: str | None = None,
encryption: EncryptionMethod = EncryptionMethod.AES256,
compression_level: CompressionLevel = CompressionLevel.DEFAULT,
prefixes: list[str | None] | None = None
) -> None
```
### compress_directory
```python
compress_directory(
input_dir: str,
output_path: str,
password: str | None = None,
encryption: EncryptionMethod = EncryptionMethod.AES256,
compression_level: CompressionLevel = CompressionLevel.DEFAULT,
include_patterns: list[str] | None = None,
exclude_patterns: list[str] | None = None
) -> None
```
### decompress_file
```python
decompress_file(
input_path: str,
output_path: str,
password: str | None = None,
*,
policy: SecurityPolicy | None = None
) -> None
```
### SecurityPolicy
```python
# Create a policy with custom limits
policy = SecurityPolicy(
max_size: int | str = None, # e.g., "10GB", "500MB", or bytes
max_ratio: int = None, # e.g., 1000 for 1000:1
allow_symlinks: bool = False
)
# Factory methods
SecurityPolicy.unlimited() # No limits (use with trusted archives only)
SecurityPolicy.strict() # 100MB max, 100:1 ratio (for untrusted content)
SecurityPolicy.strict("50MB", 50) # Custom strict limits
```
## Examples
### Compress a Directory with Filters
```python
from rustyzipper import compress_directory, EncryptionMethod
compress_directory(
"my_project/",
"backup.zip",
password="BackupP@ss",
encryption=EncryptionMethod.AES256,
include_patterns=["*.py", "*.md", "*.json"],
exclude_patterns=["__pycache__", "*.pyc", ".git", "node_modules"]
)
```
### Compress Multiple Files
```python
from rustyzipper import compress_files
compress_files(
["report.pdf", "data.csv", "summary.txt"],
"documents.zip",
password="secret",
prefixes=["reports", "data", "reports"] # Archive paths
)
```
## In-Memory and Streaming Compression
rustyzipper provides multiple APIs for different use cases, from simple in-memory operations to memory-efficient streaming for large files.
### In-Memory Compression (`compress_bytes` / `decompress_bytes`)
Compress and decompress data directly in memory without filesystem I/O. Ideal for web applications, APIs, and processing data in memory.
```python
from rustyzipper import compress_bytes, decompress_bytes, EncryptionMethod
# Compress multiple files to bytes
files = [
("hello.txt", b"Hello, World!"),
("data/config.json", b'{"key": "value"}'),
("binary.bin", bytes(range(256))),
]
zip_data = compress_bytes(files, password="secret")
# Send over network, store in database, etc.
# ...
# Decompress back to list of (filename, content) tuples
extracted = decompress_bytes(zip_data, password="secret")
for filename, content in extracted:
print(f"{filename}: {len(content)} bytes")
```
**Note:** These functions load all data into memory. For large files, use streaming APIs below.
### Streaming Compression (`compress_stream` / `decompress_stream`)
Stream data through file-like objects. Compresses in 64KB chunks to reduce memory usage.
```python
import io
from rustyzipper import compress_stream, decompress_stream, EncryptionMethod
# Compress from file handles to BytesIO
output = io.BytesIO()
with open("large_file.bin", "rb") as f1, open("another.txt", "rb") as f2:
compress_stream(
[("large_file.bin", f1), ("another.txt", f2)],
output,
password="secret"
)
zip_data = output.getvalue()
# Decompress from BytesIO
output.seek(0)
files = decompress_stream(output, password="secret")
# Or stream directly to/from files
with open("output.zip", "wb") as out:
with open("input.txt", "rb") as inp:
compress_stream([("input.txt", inp)], out, encryption=EncryptionMethod.NONE)
```
### Per-File Streaming Iterator (`open_zip_stream`)
For processing large ZIP archives with many files, use the streaming iterator to decompress one file at a time. This keeps only one decompressed file in memory at any moment.
```python
from rustyzipper import open_zip_stream, open_zip_stream_from_file
# From bytes
zip_data = open("archive.zip", "rb").read()
for filename, content in open_zip_stream(zip_data, password="secret"):
print(f"Processing {filename}: {len(content)} bytes")
process_file(content)
# Previous file's content is garbage collected
# From file handle
with open("archive.zip", "rb") as f:
for filename, content in open_zip_stream_from_file(f):
process_file(content)
# Random access and inspection
reader = open_zip_stream(zip_data)
print(f"Files: {reader.namelist()}") # List all files
print(f"Count: {len(reader)}") # Number of files
content = reader.read("specific_file.txt") # Extract by name
```
### Memory Comparison
| Function | ZIP Data | Decompressed Files | Best For |
|----------|----------|-------------------|----------|
| `decompress_bytes()` | All in memory | All at once | Small archives |
| `decompress_stream()` | Streamed | All at once | Large ZIP, small files |
| `open_zip_stream()` | All in memory | One at a time | Many files, ZIP fits in RAM |
| `open_zip_stream_from_file()` | **Streamed** | One at a time | Huge ZIP files |
### Choosing the Right Function
```
Is your ZIP file small (< 100MB)?
├── Yes → Use decompress_bytes() or open_zip_stream()
└── No → Is the ZIP itself too large for memory?
├── Yes → Use open_zip_stream_from_file() (true streaming)
└── No → Use open_zip_stream() (ZIP in memory, files streamed)
```
**Example: 10GB ZIP with 100 files (100MB each when decompressed)**
| Function | Peak Memory |
|----------|-------------|
| `decompress_bytes()` | ~10GB (all decompressed at once) |
| `open_zip_stream()` | ~compressed size + 100MB (one file at a time) |
| `open_zip_stream_from_file()` | ~100MB only (true streaming) |
### API Reference
#### compress_bytes
```python
compress_bytes(
files: list[tuple[str, bytes]],
password: str | None = None,
encryption: EncryptionMethod = EncryptionMethod.AES256,
compression_level: CompressionLevel = CompressionLevel.DEFAULT,
suppress_warning: bool = False
) -> bytes
```
#### decompress_bytes
```python
decompress_bytes(
data: bytes,
password: str | None = None
) -> list[tuple[str, bytes]]
```
#### compress_stream
```python
compress_stream(
files: list[tuple[str, BinaryIO]],
output: BinaryIO,
password: str | None = None,
encryption: EncryptionMethod = EncryptionMethod.AES256,
compression_level: CompressionLevel = CompressionLevel.DEFAULT,
suppress_warning: bool = False
) -> None
```
#### decompress_stream
```python
decompress_stream(
input: BinaryIO,
password: str | None = None
) -> list[tuple[str, bytes]]
```
#### open_zip_stream
```python
open_zip_stream(
data: bytes,
password: str | None = None
) -> ZipStreamReader
# ZipStreamReader supports:
# - Iteration: for filename, content in reader
# - len(reader): Number of files
# - reader.namelist(): List of filenames
# - reader.read(name): Extract specific file
# - reader.file_count: Number of files (property)
# - reader.total_entries: Total entries including directories (property)
```
#### open_zip_stream_from_file
```python
open_zip_stream_from_file(
input: BinaryIO,
password: str | None = None
) -> ZipFileStreamReader
# ZipFileStreamReader supports the same interface as ZipStreamReader
# but reads directly from the file handle (true streaming).
# NOTE: File handle must remain open during iteration!
```
**Usage example:**
```python
from rustyzipper import open_zip_stream_from_file
# True streaming - even 100GB ZIP files work with minimal memory
with open("huge_archive.zip", "rb") as f:
for filename, content in open_zip_stream_from_file(f):
process_file(content) # Only one file in memory at a time
```
## Security Features
rustyzipper is **secure by default** with built-in protection against common ZIP vulnerabilities.
### Built-in Protections
| Protection | Default | Description |
|------------|---------|-------------|
| **ZIP Bomb (Size)** | 2 GB max | Prevents extraction of archives that decompress to massive sizes |
| **ZIP Bomb (Ratio)** | 500:1 max | Detects suspiciously high compression ratios |
| **Path Traversal** | Always on | Blocks `../` attacks that could write outside target directory |
| **Symlinks** | Blocked | Prevents symlink-based escape attacks |
| **Memory Zeroization** | Active | Passwords are securely erased from memory after use |
| **Thread Pool Capping** | Auto | Dedicated thread pool prevents CPU starvation |
### Compat API Security Settings
The `uncompress()` function supports optional security parameters while maintaining full backward compatibility:
```python
from rustyzipper.compat import pyminizip
# Basic usage - protected by secure defaults (2GB/500:1 limits)
pyminizip.uncompress("archive.zip", "password", "output/", 0)
# Disable size limit for known-large archives
pyminizip.uncompress("large.zip", "password", "output/", 0, max_size=0)
# Custom limits for specific use cases
pyminizip.uncompress(
"archive.zip",
"password",
"output/",
0,
max_size=10 * 1024 * 1024 * 1024, # 10 GB
max_ratio=1000 # Allow 1000:1 compression ratio
)
# Full parameter list
pyminizip.uncompress(
src, # Source ZIP path
password, # Password (or None)
dst, # Destination directory
withoutpath, # 0=preserve paths, 1=flatten
max_size=None, # Max decompressed size in bytes (default: 2GB, 0=disable)
max_ratio=None,# Max compression ratio (default: 500, 0=disable)
allow_symlinks=False # Allow symlink extraction (default: False)
)
```
### Security Settings Summary
| Parameter | Default | Description |
|-----------|---------|-------------|
| `max_size` | 2 GB | Maximum total decompressed size. Set to `0` to disable. |
| `max_ratio` | 500 | Maximum compression ratio. Set to `0` to disable. |
| `allow_symlinks` | `False` | Whether to extract symbolic links (reserved for future use). |
### Handling ZIP Bomb Errors
```python
from rustyzipper.compat import pyminizip
from rustyzipper import RustyZipError
try:
pyminizip.uncompress("suspicious.zip", None, "output/", 0)
except RustyZipError as e:
if "ZipBomb" in str(e):
print("Archive exceeds safe decompression limits")
elif "SuspiciousCompressionRatio" in str(e):
print("Archive has suspiciously high compression ratio")
```
## Security Guidelines
### DO:
- Use **AES-256** for sensitive data
- Use strong passwords (12+ characters, mixed case, numbers, symbols)
- Store passwords in a password manager
- Use unique passwords for each archive
- Keep default security limits unless you have a specific reason to change them
### DON'T:
- Use ZipCrypto for sensitive data (it's weak!)
- Use weak or common passwords
- Share passwords via insecure channels
- Reuse passwords across archives
- Disable security limits (`max_size=0`) without understanding the risks
## Platform Support
| Platform | Architecture | Status |
|----------|--------------|--------|
| Windows 10+ | x64, x86, ARM64 | Supported |
| Linux (glibc) | x64, ARM64 | Supported |
| macOS 11+ | x64, ARM64 (Apple Silicon) | Supported |
### Python Version Support
- Python 3.8+
## Building from Source
### Prerequisites
- Rust 1.70+
- Python 3.8+
- maturin (`pip install maturin`)
### Build
```bash
git clone https://github.com/johnnywale/rustyzipper.git
cd rustyzipper
# Development build
maturin develop
# Release build
maturin build --release
```
### Run Tests
```bash
# Rust tests
cargo test
# Python tests
pip install pytest
pytest python/tests/
```
## Comparison with pyminizip
| Feature | pyminizip | rustyzipper |
|---------|-----------|----------|
| Maintenance Status | Abandoned | Active |
| Security Vulnerabilities | Multiple CVEs | None known |
| zlib Version | Outdated | Latest |
| AES-256 Support | No | Yes |
| Memory Safety | C/C++ risks | Rust guarantees |
| Windows Explorer Support | Yes (ZipCrypto) | Yes (ZipCrypto) |
| API Compatibility | N/A | Drop-in replacement |
| Installation | Requires compiler | Prebuilt wheels |
| Type Hints | No | Yes |
## License
Dual-licensed under MIT or Apache 2.0 at your option.
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
### Development Setup
```bash
# Clone the repository
git clone https://github.com/johnnywale/rustyzipper.git
cd rustyzipper
# Install development dependencies
pip install maturin pytest
# Build and install in development mode
maturin develop
# Run tests
cargo test # Rust tests
pytest python/tests/ -v # Python tests
```
### Supported Platforms
| Platform | Architectures |
|----------|--------------|
| Linux (glibc/musl) | x86_64, aarch64, armv7, i686 |
| Windows | x86_64, i686 |
| macOS | x86_64, aarch64 (Apple Silicon) |
## Links
- [PyPI Package](https://pypi.org/project/rustyzipper/)
- [GitHub Repository](https://github.com/johnnywale/rustyzip)
- [Issue Tracker](https://github.com/johnnywale/rustyzip/issues)
| text/markdown; charset=UTF-8; variant=GFM | RustyZip Contributors | null | null | null | MIT OR Apache-2.0 | zip, compression, encryption, aes, security, pyminizip | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Rust",
"Topic :: System :: Archiving :: Compression",
"Topic :: Security :: Cryptography",
"Typing :: Typed"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"pytest>=7.0; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"black>=23.0; extra == \"dev\"",
"mypy>=1.0; extra == \"dev\"",
"ruff>=0.1; extra == \"dev\""
] | [] | [] | [] | [
"Documentation, https://rustyzip.readthedocs.io",
"Homepage, https://github.com/johnnywale/rustyzip",
"Issues, https://github.com/johnnywale/rustyzip/issues",
"Repository, https://github.com/johnnywale/rustyzip"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:40:10.942886 | rustyzipper-1.1.1.tar.gz | 183,039 | f7/6e/690ea35ff1180c72b0f186dd9b7d7db0588c173076deb07e50d6ced8798c/rustyzipper-1.1.1.tar.gz | source | sdist | null | false | 963bac088961d69d2755bdf9e3b62624 | 8430adf3e59516cf10d00eec2896c255a16cc7535bf9b0d265a6cd386cc8645e | f76e690ea35ff1180c72b0f186dd9b7d7db0588c173076deb07e50d6ced8798c | null | [
"LICENSE-APACHE",
"LICENSE-MIT"
] | 867 |
2.4 | keras-nightly | 3.14.0.dev2026022104 | Multi-backend Keras | # Keras 3: Deep Learning for Humans
Keras 3 is a multi-backend deep learning framework, with support for JAX, TensorFlow, PyTorch, and OpenVINO (for inference-only).
Effortlessly build and train models for computer vision, natural language processing, audio processing,
timeseries forecasting, recommender systems, etc.
- **Accelerated model development**: Ship deep learning solutions faster thanks to the high-level UX of Keras
and the availability of easy-to-debug runtimes like PyTorch or JAX eager execution.
- **State-of-the-art performance**: By picking the backend that is the fastest for your model architecture (often JAX!),
leverage speedups ranging from 20% to 350% compared to other frameworks. [Benchmark here](https://keras.io/getting_started/benchmarks/).
- **Datacenter-scale training**: Scale confidently from your laptop to large clusters of GPUs or TPUs.
Join nearly three million developers, from burgeoning startups to global enterprises, in harnessing the power of Keras 3.
## Installation
### Install with pip
Keras 3 is available on PyPI as `keras`. Note that Keras 2 remains available as the `tf-keras` package.
1. Install `keras`:
```
pip install keras --upgrade
```
2. Install backend package(s).
To use `keras`, you should also install the backend of choice: `tensorflow`, `jax`, or `torch`. Additionally,
The `openvino` backend is available with support for model inference only.
### Local installation
#### Minimal installation
Keras 3 is compatible with Linux and macOS systems. For Windows users, we recommend using WSL2 to run Keras.
To install a local development version:
1. Install dependencies:
```
pip install -r requirements.txt
```
2. Run installation command from the root directory.
```
python pip_build.py --install
```
3. Run API generation script when creating PRs that update `keras_export` public APIs:
```
./shell/api_gen.sh
```
## Backend Compatibility Table
The following table lists the minimum supported versions of each backend for the latest stable release of Keras (v3.x):
| Backend | Minimum Supported Version |
|------------|---------------------------|
| TensorFlow | 2.16.1 |
| JAX | 0.4.20 |
| PyTorch | 2.1.0 |
| OpenVINO | 2025.3.0 |
#### Adding GPU support
The `requirements.txt` file will install a CPU-only version of TensorFlow, JAX, and PyTorch. For GPU support, we also
provide a separate `requirements-{backend}-cuda.txt` for TensorFlow, JAX, and PyTorch. These install all CUDA
dependencies via `pip` and expect a NVIDIA driver to be pre-installed. We recommend a clean Python environment for each
backend to avoid CUDA version mismatches. As an example, here is how to create a JAX GPU environment with `conda`:
```shell
conda create -y -n keras-jax python=3.10
conda activate keras-jax
pip install -r requirements-jax-cuda.txt
python pip_build.py --install
```
## Configuring your backend
You can export the environment variable `KERAS_BACKEND` or you can edit your local config file at `~/.keras/keras.json`
to configure your backend. Available backend options are: `"tensorflow"`, `"jax"`, `"torch"`, `"openvino"`. Example:
```
export KERAS_BACKEND="jax"
```
In Colab, you can do:
```python
import os
os.environ["KERAS_BACKEND"] = "jax"
import keras
```
**Note:** The backend must be configured before importing `keras`, and the backend cannot be changed after
the package has been imported.
**Note:** The OpenVINO backend is an inference-only backend, meaning it is designed only for running model
predictions using `model.predict()` method.
## Backwards compatibility
Keras 3 is intended to work as a drop-in replacement for `tf.keras` (when using the TensorFlow backend). Just take your
existing `tf.keras` code, make sure that your calls to `model.save()` are using the up-to-date `.keras` format, and you're
done.
If your `tf.keras` model does not include custom components, you can start running it on top of JAX or PyTorch immediately.
If it does include custom components (e.g. custom layers or a custom `train_step()`), it is usually possible to convert it
to a backend-agnostic implementation in just a few minutes.
In addition, Keras models can consume datasets in any format, regardless of the backend you're using:
you can train your models with your existing `tf.data.Dataset` pipelines or PyTorch `DataLoaders`.
## Why use Keras 3?
- Run your high-level Keras workflows on top of any framework -- benefiting at will from the advantages of each framework,
e.g. the scalability and performance of JAX or the production ecosystem options of TensorFlow.
- Write custom components (e.g. layers, models, metrics) that you can use in low-level workflows in any framework.
- You can take a Keras model and train it in a training loop written from scratch in native TF, JAX, or PyTorch.
- You can take a Keras model and use it as part of a PyTorch-native `Module` or as part of a JAX-native model function.
- Make your ML code future-proof by avoiding framework lock-in.
- As a PyTorch user: get access to power and usability of Keras, at last!
- As a JAX user: get access to a fully-featured, battle-tested, well-documented modeling and training library.
Read more in the [Keras 3 release announcement](https://keras.io/keras_3/).
| text/markdown | null | Keras team <keras-users@googlegroups.com> | null | null | Apache License 2.0 | null | [
"Development Status :: 4 - Beta",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3 :: Only",
"Operating System :: Unix",
"Operating System :: MacOS",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering",
"Topic :: Software Development"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"absl-py",
"numpy",
"rich",
"namex",
"h5py",
"optree",
"ml-dtypes",
"packaging"
] | [] | [] | [] | [
"Home, https://keras.io/",
"Repository, https://github.com/keras-team/keras"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:40:05.385183 | keras_nightly-3.14.0.dev2026022104.tar.gz | 1,205,357 | ef/f0/e064e9afb9f53ca14c95e6b24d8a8bbfb35829bc5ce8763b104e14cdca03/keras_nightly-3.14.0.dev2026022104.tar.gz | source | sdist | null | false | e45fc9679a87de0c47321dc8b4005b27 | 6e03b7ea1002732f0bb1fee4e490d6d948cc46e9ee8587c292cdbc837bb3333d | eff0e064e9afb9f53ca14c95e6b24d8a8bbfb35829bc5ce8763b104e14cdca03 | null | [] | 1,042 |
2.4 | fliiq | 1.8.0 | The AI agent that builds itself | # Fliiq
The AI agent you actually own. One command to plan, build, and automate — with persistent memory and self-generating skills.
## Quick Start
```bash
pip install fliiq
fliiq init # Creates ~/.fliiq/ + .env template
# Edit ~/.fliiq/.env with your API key (Anthropic, OpenAI, or Gemini)
fliiq # Interactive REPL from any terminal
```
> **Where does `.env` go?**
> - **Pip-installed users:** `~/.fliiq/.env` (created by `fliiq init`) — this is the standard setup.
> - **Internal developers (source checkout):** A project-root `.env` takes precedence over `~/.fliiq/.env`. Fliiq checks for a local `.env` first, then falls back to the global one.
### Project-specific setup (optional)
```bash
cd my-project
fliiq init --project # Creates .fliiq/ with SOUL.md, playbooks/, mcp.json, etc.
```
### Development install
```bash
git clone <repo-url> && cd Fliiq
pip install -e ".[dev]"
fliiq init
```
### Optional dependencies
Some skills require extra packages that aren't installed by default (to keep the base install lightweight):
| Extra | Install command | Skills enabled |
|-------|----------------|----------------|
| `all` | `pip install "fliiq[all]"` | All optional skill dependencies |
| `browser` | `pip install "fliiq[browser]"` | `web_navigate` — browser automation via browser-use |
Install everything at once or pick what you need:
```bash
pip install "fliiq[all]" # All optional skill deps
pip install "fliiq[browser]" # Just browser
```
If you try to use a skill without its dependencies, the agent will tell you exactly what to install.
## Features
**Agent loop** — Claude Code-style architecture where the model plans, executes, and evaluates in a single loop. Three modes: autonomous (full control), supervised (approve each tool call), and plan (plan only, then approve to execute).
**33 core skills** — File I/O (`read_file`, `write_file`, `edit_file`, `list_directory`), search (`grep`, `find`), system (`shell`, `deps`, `dev_server`), web (`web_search`, `fetch_html`, `web_navigate`), memory (`memory_read`, `memory_write`, `memory_search`), email (`send_email`, `receive_emails`, `mark_email_read`, `delete_email`, `archive_email`), SMS (`send_sms`, `receive_sms`), messaging (`send_telegram`, `send_telegram_audio`), audio (`text_to_speech`), Google Workspace (`google_calendar`, `google_drive`, `google_sheets`, `google_docs`, `google_slides`), contacts (`find_email`), time (`get_current_time`), and music (`spotify`).
**Persistent memory** — Curated `MEMORY.md` loaded every session. Daily logs, skill-specific memories, and keyword search across all memory files. The agent reads and updates memory naturally.
**Self-generating skills** — When the agent detects a capability gap, it researches the API, generates a complete skill (SKILL.md + fliiq.yaml + main.py + test_main.py), installs it, and verifies it works before declaring done. Each skill includes a `test_example` in fliiq.yaml with sample params and expected output keys. After install, the agent runs pytest on `test_main.py` and calls the skill as a tool — both must pass. Skills persist across sessions in `.fliiq/skills/`.
**Daemon and jobs** — Background process that runs scheduled tasks. Cron, interval, one-shot, and webhook triggers. Each job gets its own memory file and audit trail. Create jobs via CLI or let the agent create them mid-conversation.
**Customizable identity** — SOUL.md defines the agent's personality. Playbooks add domain-specific instructions. Bundled personas (`--persona product-manager`, `--persona frontend`) activate specialized expertise. All scaffolded from templates and fully editable per-project.
**Email, SMS, and Telegram** — Send and receive email (Gmail OAuth or app password), SMS (Twilio), and Telegram messages. Two modes: Fliiq's own channels (people message the bot) and managing your accounts (the agent reads your inbox, sends on your behalf).
**Google Workspace** — Full integration via OAuth. Calendar (list/create/update/delete events), Drive (list/search/upload/download/export files, create folders), Sheets (create spreadsheets, read/write cell ranges, append rows), Docs (create/read documents, insert text, batch formatting), and Slides (create/read presentations, add slides, insert text, batch updates). Multi-account support — authorize multiple Google accounts.
**Web navigation** — Browser automation powered by [browser-use](https://github.com/browser-use/browser-use). The agent can navigate websites, extract information, fill forms, and interact with web pages. Runs headless by default or with `--show-browser` to watch it work. Includes a safety checkpoint that pauses for user confirmation before any irreversible action (form submissions, payments, account creation).
**MCP support** — Connect any MCP server (stdio or streamable-http) and its tools are available to the agent alongside built-in skills. One command to add, test, and manage servers.
**Full-screen TUI** — Textual-based interface with message scrolling, mode indicator, thinking timer, and keyboard shortcuts (`fliiq tui`).
**Update notifications** — Fliiq checks PyPI for new versions in the background (zero startup impact). When an update is available, you'll see a one-liner in the REPL, TUI, or after `fliiq run` completes. Disable with `FLIIQ_NO_UPDATE_CHECK=1`.
## Usage
```bash
# Interactive (default)
fliiq # REPL (autonomous mode)
fliiq --mode supervised # REPL in supervised mode
fliiq tui # Full-screen TUI
# Single-shot
fliiq run "build a Flask todo app"
fliiq run "what time is it" --mode autonomous
fliiq run "complex task" --model opus-4.6 # Use a specific model
fliiq run "find info on example.com" --show-browser # Visible browser
fliiq plan "refactor the auth module"
# Personas — specialized expertise
fliiq run "write a PRD for user onboarding" --persona product-manager
fliiq run "build a responsive nav component" --persona frontend
fliiq --persona product-manager # REPL in PM mode
# Models
fliiq models # Show model aliases
fliiq run "task" -m gpt-4.1 # Short flag works too
# Skills
fliiq skill-list # Show all skills with source (core/local)
fliiq skill-promote <name> # Promote local skill to core
# Identity and customization
fliiq soul show # Display SOUL.md (default + overrides)
fliiq soul edit # Open .fliiq/SOUL.md in $EDITOR
fliiq soul reset # Remove overrides, revert to defaults
fliiq playbook list # List playbooks with source (custom/bundled)
fliiq playbook show coding # Display a playbook
fliiq playbook create devops # Scaffold a new custom playbook
# Google accounts
fliiq google auth # Authorize a Google account (Calendar, Gmail, Drive, Sheets, Docs, Slides)
fliiq google accounts # List authorized accounts
# MCP servers
fliiq mcp add github --command npx --args "@modelcontextprotocol/server-github"
fliiq mcp add my-api --url https://mcp.example.com/mcp
fliiq mcp list # Show configured servers
fliiq mcp test # Validate connections
fliiq mcp remove github # Remove a server
# Daemon and jobs
fliiq daemon start # Start background daemon
fliiq daemon start --detach # Detach to background
fliiq daemon status # Check if running
fliiq daemon stop # Stop daemon
fliiq job list # List all jobs
fliiq job create # Create a job interactively
fliiq job run <name> # Manual trigger
fliiq job logs <name> # View run history
fliiq job delete <name> # Remove a job
```
### Chat Commands
Inside the REPL (`fliiq`):
| Command | Action |
|-----------|-------------------------------------------------|
| `/mode` | Cycle mode (plan -> supervised -> autonomous) |
| `/status` | Show session info |
| `/clear` | Reset conversation history |
| `/help` | Show available commands |
| `/exit` | Exit chat |
## Architecture
```
fliiq/
cli/ # Typer CLI, Rich display, Textual TUI, REPL
runtime/
agent/ # Agent loop, tool registry, prompt assembly, audit
llm/ # LLM providers (Anthropic, OpenAI, Gemini) + failover
skills/ # Skill loader, base class, installer
mcp/ # MCP client, server connections, tool forwarding
planning/ # Domain detection, playbook loading, reflection
memory/ # Memory manager, keyword retrieval
scheduler/ # Job executor, scheduler, run logging
browser/ # Browser automation engine (browser-use integration)
api/ # FastAPI daemon, webhook receiver
data/ # Bundled skills, SOUL.md, playbooks, templates
```
**Agent loop** (`runtime/agent/loop.py`): Model calls tools, tools return results, loop continues until the model stops or hits max iterations. Mode enforcement filters available tools and gates execution.
**Skill system** (`runtime/skills/`): Each skill is a directory with `SKILL.md` (metadata), `fliiq.yaml` (schema + test_example), `main.py` (async handler), and optionally `test_main.py` (pytest tests). Self-generated skills include mandatory test verification — the agent runs pytest and calls the skill before marking it complete. Discovery scans bundled skills first, then project-level overrides, then user-local `.fliiq/skills/`.
**Memory** (`runtime/memory/`): Files in `.fliiq/memory/`. `MEMORY.md` (curated, always in prompt), daily logs (`YYYY-MM-DD.md`), skill memories (`skills/*.md`). Agent reads/writes via memory skills.
## Configuration
### API Keys (`.env`)
At least one required:
```
ANTHROPIC_API_KEY=your-key
OPENAI_API_KEY=your-key
GEMINI_API_KEY=your-key
```
Priority: Anthropic > OpenAI > Gemini (when multiple keys are set).
### Provider Switching
When multiple API keys are set, use `--provider` to choose which LLM to use:
```bash
fliiq --provider openai # REPL with OpenAI/GPT-4o
fliiq run "task" --provider gemini # Single-shot with Gemini
fliiq tui --provider anthropic # TUI with Claude
```
For a persistent default, set `FLIIQ_PROVIDER` in your `.env`:
```
FLIIQ_PROVIDER=openai
```
Priority: `--provider` flag > `FLIIQ_PROVIDER` env var > first API key found.
### Model Selection
Switch models per-command with `--model` (or `-m`):
```bash
fliiq run "build a Jira skill" --model opus-4.6 # Use Opus for complex tasks
fliiq run "check my inbox" --model sonnet-4.5 # Use Sonnet for daily tasks
fliiq run "task" --model gpt-4.1 # Use OpenAI GPT-4.1
```
Model aliases are defined in `~/.fliiq/models.yaml` (created by `fliiq init`). View them with:
```bash
fliiq models
```
Default aliases shipped with `fliiq init`:
| Anthropic | OpenAI | Gemini |
|-----------|--------|--------|
| `opus-4.6` | `gpt-4.1` | `gemini-2.5-pro` |
| `sonnet-4.5` | `gpt-4.1-mini` | `gemini-2.5-flash` |
| `sonnet-4.0` | `gpt-4o` | |
| `haiku-4.5` | `gpt-4o-mini` | |
| | `o3` | |
| | `o3-mini` | |
| | `o4-mini` | |
Edit `~/.fliiq/models.yaml` to add your own aliases for Ollama, Mistral, DeepSeek, or any other provider. Use the format `name-version` to stay consistent:
```yaml
# ~/.fliiq/models.yaml
aliases:
# ... default aliases above ...
# Custom aliases — add yours here
mistral-large: mistral-large-latest
mistral-small: mistral-small-latest
mistral-codestral: codestral-latest
deepseek-v3: deepseek-chat
deepseek-coder: deepseek-coder
llama-3.2: llama3.2:latest
qwen-2.5: qwen2.5:latest
```
Then use them like any other alias:
```bash
fliiq run "task" --model mistral-large --provider openai
```
Any string not found in aliases is passed through as-is to the provider API.
Priority: `--model` flag > env var (`ANTHROPIC_MODEL`, etc.) > hardcoded default.
Override the default model persistently via env var:
```
ANTHROPIC_MODEL=claude-opus-4-6
OPENAI_MODEL=gpt-4.1
GEMINI_MODEL=gemini-2.5-flash
```
### Self-Hosted LLMs
Connect any OpenAI-compatible server (Ollama, vLLM, llama.cpp, LM Studio, LocalAI) using `OPENAI_BASE_URL`:
```
OPENAI_API_KEY=not-needed
OPENAI_BASE_URL=http://localhost:11434/v1
OPENAI_MODEL=llama3.2
```
**Quick start with Ollama:**
```bash
# Install and start Ollama (https://ollama.com)
ollama pull llama3.2
ollama serve
# Add to ~/.fliiq/.env
echo 'OPENAI_API_KEY=not-needed' >> ~/.fliiq/.env
echo 'OPENAI_BASE_URL=http://localhost:11434/v1' >> ~/.fliiq/.env
echo 'OPENAI_MODEL=llama3.2' >> ~/.fliiq/.env
# Run with local model
fliiq --provider openai
```
If you also have a cloud API key set, switch between local and cloud with `--provider`:
```bash
fliiq --provider openai # Local Ollama
fliiq --provider anthropic # Cloud Claude
```
Tool/skill support (email, calendar, etc.) depends on the model's function calling capability. Most large models (Llama 3.2+, Mistral, Qwen) support it via the OpenAI-compatible API.
`ANTHROPIC_BASE_URL` is also supported for Anthropic-compatible proxies.
### Global Directory (`~/.fliiq/`)
Created by `fliiq init` — used from any terminal:
```
~/.fliiq/
.env # API keys + Fliiq channel credentials
user.yaml # Your identity (name, emails, timezone)
models.yaml # Model aliases for --model flag
memory/ # Persistent memory files
audit/ # Audit trails from agent runs
skills/ # User-generated skills (available everywhere)
```
### Project Directory (`.fliiq/`) — optional
Created by `fliiq init --project` — overrides global for this project:
```
.fliiq/
SOUL.md # Agent personality overrides (scaffolded from template)
playbooks/ # Custom domain playbooks
mcp.json # MCP server connections
memory/ # Project-specific memory
audit/ # Project audit trails
jobs/ # Scheduled job definitions (YAML)
skills/ # Project-specific skills
```
Resolution: local `.fliiq/` > global `~/.fliiq/` > bundled defaults.
### Agent Identity (SOUL.md)
SOUL.md defines the agent's personality, communication style, and behavioral rules. A bundled default ships with the package. To customize for your project:
```bash
fliiq soul edit # Opens .fliiq/SOUL.md in $EDITOR (creates from template if missing)
fliiq soul show # See default + your overrides
fliiq soul reset # Delete overrides, revert to bundled default
```
Your `.fliiq/SOUL.md` is appended to the default as "User Overrides" — you only need to specify what you want to change. The bundled default is never modified.
### Playbooks & Personas
Playbooks are domain-specific instructions loaded into the agent's system prompt. Three come bundled:
| Playbook | Activated by | Focus |
|----------|-------------|-------|
| `coding` | Auto-detected from prompt | Engineering standards, architecture, verification |
| `product-manager` | `--persona product-manager` | PRD writing, ticket writing, prioritization, sprint planning |
| `frontend` | `--persona frontend` | Component architecture, accessibility, visual design quality, performance |
**Explicit activation** — use `--persona` to force a specific playbook:
```bash
fliiq run "write user stories" --persona product-manager
fliiq --persona frontend # REPL with frontend expertise
```
**Auto-detection** — when no `--persona` is given, Fliiq matches keywords in your prompt. When 2+ keywords match a playbook's domain, it loads automatically.
**Custom playbooks:**
```bash
fliiq playbook create devops # Scaffold .fliiq/playbooks/devops.md
fliiq playbook list # Show all (custom + bundled)
fliiq playbook show coding # Display content
```
Edit the playbook and add trigger keywords on the `# Keywords:` line. User playbooks in `.fliiq/playbooks/` override bundled ones with the same name.
### MCP Servers
Connect external tools via the [Model Context Protocol](https://modelcontextprotocol.io). Fliiq supports stdio and streamable-http transports.
```bash
# Add a stdio server (e.g. from npm)
fliiq mcp add github --command npx --args "@modelcontextprotocol/server-github"
# Add a streamable-http server
fliiq mcp add my-api --url https://mcp.example.com/mcp
# Verify it works
fliiq mcp test github
# List / remove
fliiq mcp list
fliiq mcp remove github
```
MCP tools are auto-discovered at startup and registered alongside built-in skills. The agent sees them as regular tools (prefixed with `mcp_{server}_{tool}`). Connection failures are non-fatal — other servers and skills still work.
Config is stored in `.fliiq/mcp.json` (scaffolded by `fliiq init --project`). You can also edit it directly:
```json
{
"servers": {
"github": {
"command": "npx",
"args": ["@modelcontextprotocol/server-github"],
"transport": "stdio"
}
}
}
```
### User Profile (`~/.fliiq/user.yaml`)
Your identity file — loaded into every agent session so the agent knows who you are. When you say "my email" or "my calendar," the agent uses these accounts.
```yaml
name: John Doe
emails:
- address: John@gmail.com
label: personal
- address: John@work.com
label: work
timezone: America/New_York
```
Created by `fliiq init`. Emails are auto-added when you run `fliiq google auth`.
### Google Account Integration
Authorize your Google accounts so the agent can manage your Gmail, Calendar, Drive, Sheets, Docs, and Slides:
```bash
fliiq google auth # Opens browser for OAuth consent (full Google Workspace)
fliiq google accounts # List authorized accounts
```
Run `fliiq google auth` once per Google account. Each gets OAuth tokens stored in `~/.fliiq/google_tokens.json`. After auth, you'll be prompted to add the email to your user profile.
**Prerequisites:**
1. Create a project at [Google Cloud Console](https://console.cloud.google.com)
2. Enable **Google Calendar API**, **Gmail API**, **Google Drive API**, **Google Sheets API**, **Google Docs API**, and **Google Slides API**
3. Create OAuth 2.0 credentials (Desktop app, redirect URI `http://localhost:8080/callback`)
4. Add these to your `.env`:
```
GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
```
Then ask the agent things like "check my email," "book a meeting tomorrow at 3pm," "list my Drive files," "read the budget spreadsheet," or "add a slide to my presentation."
### Communication Channels
Fliiq supports two distinct use cases for email, SMS, and messaging:
**Use Case 1: Fliiq's own channels (talk TO Fliiq)**
Give Fliiq its own email, phone number, and Telegram bot so people can message it directly — like texting an assistant.
```
# Fliiq's bot email (receives messages on behalf of Fliiq)
FLIIQ_GMAIL_ADDRESS=fliiq-bot@gmail.com
FLIIQ_GMAIL_APP_PASSWORD=your-app-password
# Fliiq's phone number (Twilio)
TWILIO_ACCOUNT_SID=your-sid
TWILIO_AUTH_TOKEN=your-token
TWILIO_PHONE_NUMBER=+1234567890
# Fliiq's Telegram bot
TELEGRAM_BOT_TOKEN=your-bot-token
TELEGRAM_ALLOWED_CHAT_IDS=123456789
```
These are Fliiq's OWN inboxes. The daemon monitors them for inbound messages and responds automatically.
**Telegram Setup**
1. Create a bot via [@BotFather](https://t.me/BotFather) on Telegram and copy the bot token
2. Add `TELEGRAM_BOT_TOKEN=your-bot-token` to `~/.fliiq/.env`
3. Run the interactive setup to detect your chat ID:
```bash
fliiq telegram setup
```
This will prompt you to send a message to your bot, then auto-detect and save your chat ID.
**Manual alternative:** Add `TELEGRAM_ALLOWED_CHAT_IDS=<chat_id>` to `~/.fliiq/.env` directly. Comma-separate multiple IDs.
> **Required:** When `TELEGRAM_BOT_TOKEN` is set, `TELEGRAM_ALLOWED_CHAT_IDS` must also be set. The daemon will refuse to start without it — this prevents unauthorized users from accessing your agent.
**Text-to-Speech (MiniMax)**
Generate audio pronunciation and send it via Telegram. Ask Fliiq "how do you say X in Cantonese?" and get back Chinese characters + a playable audio message. Supports Cantonese, Mandarin, English, and other languages via MiniMax TTS.
```
MINIMAX_API_KEY=your-api-key
MINIMAX_GROUP_ID=your-group-id
```
Get these from [minimax.io](https://www.minimax.io). The agent uses `text_to_speech` to generate MP3 audio and `send_telegram_audio` to deliver it via Telegram.
**Use Case 2: Your accounts (Fliiq manages FOR you)**
Authorize your personal/work Google accounts so Fliiq can read your email, send on your behalf, and manage your calendar.
```bash
fliiq google auth # Authorize each Google account via OAuth
```
Emails go in `~/.fliiq/user.yaml`, and the agent uses OAuth (not app passwords) to access them. This is what powers "check my email" and "schedule a meeting."
**The two use cases are independent.** You can set up one, both, or neither. The agent's system prompt distinguishes between "Fliiq's email" (from `.env`) and "the user's email" (from `user.yaml`).
### Troubleshooting
```bash
fliiq doctor # Verify setup: API keys, SOUL.md, playbooks, MCP, skills
```
## Security
Fliiq gives an LLM agent access to your filesystem, email, SMS, Telegram, and shell commands. That power is the point — but it comes with real risks.
### What Fliiq protects
- **Credential file deny list** — The agent cannot read or write `~/.fliiq/.env`, `~/.fliiq/google_tokens.json`, `~/.fliiq/daemon.secret`, or anything in `~/.ssh/`, `~/.aws/`, `~/.gnupg/`. This prevents prompt injection attacks from exfiltrating secrets.
- **Prompt injection defense** — All inbound external content (Telegram messages, emails, SMS, webhook payloads) is wrapped in `<external_message>` tags with a system prompt instruction telling the agent to never follow instructions from external sources.
- **Telegram allowlist** — `TELEGRAM_ALLOWED_CHAT_IDS` is required when a bot token is set. Unauthorized users get a hardcoded rejection reply — no LLM call, no tool access.
- **Daemon API authentication** — All `/api/*` routes require a Bearer token (auto-generated at `~/.fliiq/daemon.secret`). Prevents local CSRF and rogue processes from triggering agent execution.
- **Package install validation** — The `deps` skill validates package names against a regex and uses `subprocess_exec` (no shell) to prevent command injection.
### What Fliiq does NOT protect
- **Your project files** — The agent has full read/write access to your working directory. This is by design (it needs to edit your code), but a prompt injection attack could modify or delete project files.
- **Self-corruption** — Fliiq can overwrite its own local configuration (`~/.fliiq/jobs/`, `~/.fliiq/user.yaml`, skill files, etc.). If the agent corrupts its local state, reset with:
```bash
rm -rf ~/.fliiq && fliiq init
```
This is safe — core package code lives in `site-packages/` (read-only via pip install). Only local config and job definitions are lost.
- **System prompt extraction** — An attacker with access to the agent can extract the system prompt. This is a soft defense only (LLMs can be jailbroken).
- **Audit log contents** — Audit logs in `~/.fliiq/audit/` may contain sensitive conversation data.
### Best practices
1. **Use supervised mode for untrusted tasks** — `fliiq run "..." --mode supervised` requires your approval before each tool call.
2. **Review scheduled jobs** — Jobs run autonomously in the daemon. Audit `~/.fliiq/jobs/` to know what's running.
3. **Don't put secrets in prompts** — The agent resolves credentials from env vars and OAuth tokens automatically. Never include passwords in job prompts or Telegram messages.
4. **Back up your project** — Use git. The agent writes files. Commits give you rollback.
5. **Rotate daemon secret after exposure** — Delete `~/.fliiq/daemon.secret` and restart the daemon to regenerate.
## Development
```bash
# Install with dev dependencies only
pip install -e ".[dev]"
# Install with dev + all optional skill dependencies
pip install -e ".[dev,all]"
# Install with dev + specific extras
pip install -e ".[dev,browser]"
# Lint
ruff check fliiq/
# Tests
pytest tests/
# Run specific test file
pytest tests/test_agent_loop.py -v
```
### Tech Stack
- **Python 3.12+**, **Typer** (CLI), **Rich** (display), **Textual** (TUI)
- **FastAPI + uvicorn** (daemon), **croniter** (scheduling)
- **Anthropic / OpenAI / Gemini** SDKs (LLM providers)
- **structlog** (logging), **pytest** (testing), **ruff** (linting)
## License
Copyright (c) 2024-2026 Fliiq AI. All rights reserved.
| text/markdown | Fliiq AI | null | null | null | Proprietary | null | [
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"fastapi>=0.115.0",
"uvicorn[standard]>=0.34.0",
"typer[all]>=0.15.0",
"pydantic>=2.10.0",
"httpx>=0.28.0",
"markdownify>=0.14.0",
"pyyaml>=6.0",
"structlog>=24.0",
"anthropic>=0.40.0",
"openai>=1.50.0",
"google-genai>=1.0.0",
"python-dotenv>=1.0.0",
"rich>=13.0",
"textual>=0.47.0",
"croniter>=1.4.0",
"mcp>=1.0.0",
"fliiq[browser]; extra == \"all\"",
"browser-use>=0.11.0; extra == \"browser\"",
"langchain-anthropic>=0.3.0; extra == \"browser\"",
"langchain-openai>=0.3.0; extra == \"browser\"",
"langchain-google-genai>=2.0.0; extra == \"browser\"",
"pytest>=8.0; extra == \"dev\"",
"pytest-asyncio>=0.24; extra == \"dev\"",
"ruff>=0.8.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/fliiq-ai/fliiq",
"Repository, https://github.com/fliiq-ai/fliiq",
"Issues, https://github.com/fliiq-ai/fliiq/issues",
"Changelog, https://github.com/fliiq-ai/fliiq/blob/main/CHANGELOG.md"
] | twine/6.1.0 CPython/3.12.2 | 2026-02-21T04:36:37.079226 | fliiq-1.8.0.tar.gz | 270,714 | 50/62/4532e1ef5d71fc6b77739fa7c9a757834f4d5bc99835963408b4c8ff0fca/fliiq-1.8.0.tar.gz | source | sdist | null | false | 686ebed17855cb656189e5505d51b597 | 1cd2ab5ef53c67a59bace1fa1aed86ea82bd325469e797d0d49a737e4283732d | 50624532e1ef5d71fc6b77739fa7c9a757834f4d5bc99835963408b4c8ff0fca | null | [] | 232 |
2.4 | arpakitlib | 1.9.40 | arpakitlib | # arpakitlib
## 🚀 Simplify Your Development Workflow
A collection of lightweight and convenient development tools by arpakit, designed to simplify and accelerate your
workflow
---
### Supported Python version
- Python 3.12.4+
---
### Installation methods
```
poetry add arpakitlib
# or
pip add arpakitlib
# or
poetry add git+https://github.com/ARPAKIT-Company/arpakitlib.git@master
```
---
## ❤️ Made by ARPAKIT Company ❤️
| text/markdown | arpakit_company | support@arpakit.com | null | null | null | arpakitlib, arpakit, arpakit-company, arpakitcompany, arpakit_company | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries"
] | [] | null | null | <4.0,>=3.12.4 | [] | [] | [] | [
"aio-pika<10.0.0,>=9.5.4",
"aiogram<4.0.0,>=3.22.0",
"aiohttp<4.0.0,>=3.11.16",
"aiohttp-socks<0.11.0,>=0.10.1",
"aiosmtplib<5.0.0,>=4.0.0",
"aiosqlite<0.22.0,>=0.21.0",
"alembic<2.0.0,>=1.14.1",
"asyncpg<0.31.0,>=0.30.0",
"asyncssh<3.0.0,>=2.21.1",
"bs4<0.0.3,>=0.0.2",
"cachetools<6.0.0,>=5.5.1",
"celery<6.0.0,>=5.4.0",
"email-validator<3.0.0,>=2.2.0",
"emoji<3.0.0,>=2.14.1",
"fastapi<0.119.0,>=0.118.0",
"gunicorn<24.0.0,>=23.0.0",
"itsdangerous<3.0.0,>=2.2.0",
"markdown<4.0,>=3.7",
"openai<3.0.0,>=2.6.1",
"openpyxl<4.0.0,>=3.1.5",
"orjson<4.0.0,>=3.10.15",
"pandas<3.0.0,>=2.3.3",
"paramiko<5.0.0,>=4.0.0",
"pika<2.0.0,>=1.3.2",
"poetry<3.0.0,>=2.0.1",
"poetry-plugin-export>=1.9.0",
"psycopg2-binary<3.0.0,>=2.9.10",
"pulp<3.0.0,>=2.9.0",
"pydantic<3.0.0,>=2.10.5",
"pydantic-settings<3.0.0,>=2.7.1",
"pyjwt<3.0.0,>=2.10.1",
"pyminizip<0.3.0,>=0.2.6",
"pymongo<5.0.0,>=4.15.5",
"pytelegrambotapi<5.0.0,>=4.29.1",
"pytest<9.0.0,>=8.4.2",
"pytz<2025.0,>=2024.2",
"qrcode<9.0,>=8.2",
"rapidfuzz<4.0.0,>=3.14.1",
"redis<7.0.0,>=6.4.0",
"requests-ntlm<2.0.0,>=1.3.0",
"requests[socks]<3.0.0,>=2.32.3",
"sqladmin<0.22.0,>=0.21.0",
"sqlalchemy<3.0.0,>=2.0.37",
"twine<7.0.0,>=6.1.0",
"uvicorn<0.38.0,>=0.37.0",
"xlrd<3.0.0,>=2.0.1",
"xlsxwriter<4.0.0,>=3.2.5"
] | [] | [] | [] | [
"Documentation, https://github.com/ARPAKIT-Company/arpakitlib",
"Homepage, https://github.com/ARPAKIT-Company/arpakitlib",
"arpakit_company_site, https://arpakit.com",
"arpakit_company_support_tg, https://t.me/arpakit_company_support",
"git_repository, https://github.com/ARPAKIT-Company/arpakitlib",
"telegram_channel, https://t.me/arpakitlib"
] | poetry/2.3.2 CPython/3.12.4 Linux/6.17.0-14-generic | 2026-02-21T04:36:36.435229 | arpakitlib-1.9.40-py3-none-any.whl | 69,730 | d9/a5/9bf82487e593dacf9fb31dbd22e5306fe3b6ec98a028abfbf67c5d060c62/arpakitlib-1.9.40-py3-none-any.whl | py3 | bdist_wheel | null | false | 573dc613970f3169fe207652f398421f | abfa67b24cb1be017f67c073522963e03086cd86d270f24b2c21e52463a0d022 | d9a59bf82487e593dacf9fb31dbd22e5306fe3b6ec98a028abfbf67c5d060c62 | Apache-2.0 | [
"LICENSE"
] | 304 |
2.4 | eva-exploit | 3.4.2 | Exploit Vector Agent | 
<div align="center">
# ⫻ 𝝣.𝗩.𝝠
## ⮡ Exploit Vector Agent
<br>
**Autonomous offensive security AI for guiding pentest processes**
[](https://github.com/ARCANGEL0/EVA)
[](https://github.com/ARCANGEL0/EVA)
[](https://github.com/ARCANGEL0/EVA/fork)
[](https://github.com/ARCANGEL0/EVA)
[](LICENSE)
[](#)
[](#)
</div>
<br> <br>
<div align="center">
[](https://github.com/ARCANGEL0/NekoCLI)
</div>
---
## 𝝺 Overview
**EVA** is an AI penetration testing agent that guides users through complete pentest engagements with AI-powered attack strategy, autonomous command generation, and real-time vulnerability analysis based on outputs. The goal is not to replace the pentest professional but to guide and assist and provide faster results.
### Main funcionalities
- **🜂 Intelligent Reasoning**: Advanced AI-driven analysis and attack path identification depending on query.
- **ⵢ Automated Enumeration**: Systematic target reconnaissance and information gathering based on provided target.
- **ꎈ Vulnerability Assessment**: AI-powered vulnerability identification and exploitation strategies, suggesting next steps for vulnerability or OSINT.
- **⑇ Multiple AI Backends**: Support for Ollama, OpenAI GPT, Anthropic, Gemini, G4F.dev and custom API endpoints
- **ㄖ Session Management**: Persistent sessions and chats
- **⑅ Interactive Interface**: Real-time command execution and analysis of output in multi-stage.
---
## ⵢ EVA Logic & Pentest Process Flow
```mermaid
graph TD
A[🜂 EVA Launch] --> B{🢧 Session Selection}
B -->|Existing Session| C[🢧 Load Session Data]
B -->|New Session| D[߭ Initialize Session]
C --> E[ㄖ Select AI Backend]
D --> E
E --> F[🦙 Ollama Local]
E --> G[⬡ OpenAI GPT]
E --> J1[✶ Anthropic Claude]
E --> J2[✦ Google Gemini]
E --> H[⟅ Custom API]
E --> I[🜅 G4F.dev Provider]
F --> J[Pentest Shell]
G --> J
J1 --> J
J2 --> J
H --> J
I --> J
J --> K[⌖ Target Definition]
K --> L[🧠 AI Pentest Strategy]
L --> M[🝯 Reconnaissance Phase]
M --> N[➤_ Execute Commands]
N --> O[ꎐ Analyze Results]
O --> P{ᐈ Vulnerabilities Found?}
P -->|Yes| Q[🖧 Exploitation Planning]
P -->|No| R[⭯ More Enumeration]
R --> L
Q --> S[⚡ Exploitation Phase]
Q --> T[Export graphs and mapped networks]
S --> U[➤_ Execute Exploit]
U --> V{🞜 Access Gained?}
V -->|Yes| W[𐱃 Privilege Escalation]
V -->|Failed| X[⭯ Alternative Methods]
X --> Q
W --> Y[𐦝 Post-Exploitation]
Y --> Z{🞜 Objectives Met?}
Z -->|Generate Report| AA[📋 Generate Report]
Z -->|Exit and Save| AB[💾 Save & Exit]
Z -->|No| AC[🔍 Continue Pentest]
AC --> L
AA --> AB
subgraph "🍎 EVA "
AD[⯐ Attack Strategy AI]
AE[𝚵 Session Memory]
AF[ᐮ Vulnerability Analysis]
AG[CVE DATABASE SEARCH]
AH[𐰬 Output Processing]
end
L --> AD
AD --> AE
O --> AF
AF --> AG
AG --> AH
AH --> L
```
---
<details>
<summary><h2>➤ Quick Start</h2></summary>
### 🍎 Installation
#### Ollama for local endpoint (required for local models and eva exploit database)
```bash
curl -fsSL https://ollama.ai/install.sh | shr
```
#### pip installation
```bash
pip install eva-exploit
eva
```
#### EVA github installation
```bash
git clone https://github.com/ARCANGEL0/EVA.git
cd EVA
chmod +x eva.py
./eva.py
# Adding it to PATH to be acessible anywhere
sudo mv eva.py /usr/local/bin/eva
```
### ⬢ Configuring EVA.
When starting EVA, it will automatically handle:
- ✅ API key setup (According to Model)
- ✅ Ollama model download (Default set as whiterabitv2, feel free to change to any other desired model)
- ✅ Session directory creation
- ✅ Dependencies installation
<strong> If you wish to modify endpoints, ollama models, API Keys or configure EVA, please run: </strong>
```bash
eva --config
```
### 📁 Directory Structure of EVA
```
~/EVA_data/
├── sessions/ # Session storage
│ ├── session1.json
│ ├── session2.json
│ └── ...
├── reports/ # Vulnerability reports
│ ├── report1.html
│ ├── report1.pdf
│ └── ...
└── attack_maps/ # Attack vector maps in HTML/JS
├── attack_surface1.html
├── attack_surface2.html
└── ...
```
### ꀬ Where to change EVA options
```bash
eva --config
```
<strong> Will display the following configuration: </strong>
```python
API_ENDPOINT = "NOT_SET"
G4F_MODEL="gpt-oss-120b"
G4F_URL="https://api.gpt4free.workers.dev/api/novaai/chat/completions"
OLLAMA_MODEL = "ALIENTELLIGENCE/whiterabbitv2"
SEARCHVULN_MODEL = "gpt-oss:120b-cloud"
SEARCVULN_URL = "https://ollama.com/api/chat"
OLLAMA_API_KEY = "NOT_SET"
OPENAI_API_KEY = "NOT_SET"
ANTHROPIC_API_KEY = "NOT_SET"
GEMINI_API_KEY = "NOT_SET"
ANTHROPIC_MODEL = "claude-3-5-sonnet-latest"
GEMINI_MODEL = "gemini-2.0-flash"
OLLAMA_CLOUD_TIMEOUT = 45
CONFIG_DIR = Path.home() / "EVA_data" #
SESSIONS_DIR = CONFIG_DIR / "sessions"
REPORTS_DIR = CONFIG_DIR / "reports"
MAPS_DIR = CONFIG_DIR / "attack_maps"
TERMS_ACCEPTEDTHING = CONFIG_DIR / ".confirm"
CONFIG_DIR.mkdir(parents=True, exist_ok=True)
SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
REPORTS_DIR.mkdir(parents=True, exist_ok=True)
MAPS_DIR.mkdir(parents=True, exist_ok=True)
username = os.getlogin()
MAX_RETRIES = 10 ### maximum retries for fetching requests
RETRY_DELAY = 10 ### delay between requests to avoid rate limit error
```
</details>
<details>
<summary><h2>🖴 Usage Guide</h2></summary>
### Initialization
```bash
python3 eva.py
# or if installed via pip:
eva
# open config.py in your default editor
eva --config
# deletes all sessions and files
eva --delete
# vulnerability / exploit intel search
eva --search i have a wingftp server running on version 4.7.3, find me exploits for it
# run eva default launcher
eva
```
1. **Select Session**: Choose existing session or create new one
2. **Choose AI Backend**:
- **Ollama** (Recommended): Local AI with WhiteRabbit-Neo model
- **GPT-5**: OpenAI's latest model (requires API key)
- **G4F**: Uses g4f.dev endpoints with models running GPT5.2, feel free to change model used.
- **Anthropic**: Claude API backend (requires API key)
- **Gemini**: Google Gemini API backend (requires API key)
- **Custom API**: Your own API endpoint if desired
3. In the input field of chat, type in your request or what you need assistance with for EVA to help you!
> USER > i need help with a CTF machine, ip is 10.10.16.81
### After making a request, commands will be provided and the pentest workflow will start, use commands below as reference.
| Command | Description |
|---------|-------------|
| `/exit` / `/quit` | Exit EVA and save session |
| `/model` | Change AI backend |
| `/rename` | Rename the current session |
| `/search <query>` or `search <query>` | Run exploit/vulnerability intel search inside current chat session and feed results into next analysis |
| `/report` | Generates a PDF/HTML report with latest findings on session |
| `/map` | Generates a html file with attack surface map of session |
| `/menu` | Return to session menu |
| `R` | Run suggested command |
| `S` | Skip command |
| `A` | Ask for next step |
| `Q` | Quit session |
### ㄖ Example of chat session
> demonstration video.
```
USER > I'm on a Windows target at IP 10.10.11.95, what should I enumerate first?
[ANALYSIS]
Based on the Windows environment, I need to perform comprehensive
enumeration focusing on:
1. System Information (OS version, patches, architecture)
2. Network Services (ports, services, listening processes)
3. User Context (current user, groups, privileges)
4. Security Controls (AV, firewall, UAC settings)
5. Potential Attack Vectors (SMB, RDP, IIS, etc.)
Let me start with basic system reconnaissance to understand the target better...
> execute: nmap -sC -sV -O 10.10.10.10
| [R]un | [S]kip | [A]sk | [G]enerate HTML Report | [V]iew attack map | [Q]uit |
> R
```
</details>
<details>
<summary><h2>Ξ AI Backends</h2></summary>
### 🦙 Ollama (Recommended)
- **Model**: `ALIENTELLIGENCE/whiterabbitv2"` (best one for OffSec)
- ✅ Complete offline operation
- ✅ No API costs
- ✅ Privacy-focused
- ❌ Higher CPU/GPU usage, recommended for machines above 8GB+ VRAM/RAM
- ❌ Heavier model, ~9.8gb model
### ⬡ OpenAI GPT
- **Models**: GPT-5, GPT-4.1 (fallback)
- **About**:
- ✅ Faster reasoning
- ✅ Extensive knowledge base
- ✅ Continuous updates
- ❌ Paid, requires apikey
### ᛃ G4F.dev
- **Models**: GPT-5-1
- **About**:
- ✅ Updated information in real-time (usually)
- ✅ Quick responses
- ❌ Might be unstable or down sometimes, low stability.
### ⟅ Custom API
- **Endpoint**: Configurable in `API_ENDPOINT` to use your own as you wish.
- **About**:
- ✅ Custom model integration
- ✅ Modifiable as you wish
### ✶ Anthropic
- **Model**: Configurable via `ANTHROPIC_MODEL`
- **About**:
- ✅ Strong reasoning quality
- ✅ Stable API
- ❌ Requires `ANTHROPIC_API_KEY`
### ✦ Gemini
- **Model**: Configurable via `GEMINI_MODEL`
- **About**:
- ✅ Fast response latency
- ✅ Native JSON output mode and better parsing, usually provides best results
- ❌ Requires `GEMINI_API_KEY`
</details>
<details>
<summary><h2>⑇ Roadmap</h2></summary>
- [x] **⬢ OpenAI integration**: Integrated OpenAI into EVA
- [x] **⬢ G4F.DEV**: Added G4F endpoints to free GPT5 usage.
- [x] **⬢ Custom API**: Add custom endpoint besides ollama and OpenAI
- [x] **⬢ Automated Reporting**: Concise HTML report generation (+ optional PDF via wkhtmltopdf)
- [x] **⬢ CVE Database Integration**: Real-time vulnerability data
- [x] **⬢ Visual Attack Maps**: Interactive network diagrams such as connections or such, like Kerberos domains and AD devices.
- [ ] **⬡ Cloud Integration**: AWS/GCP deployment ready
- [ ] **⬡ Web Interface**: Browser-based EVA dashboard
</details>
<details>
<summary><h2>⨹ Legal Notice</h2></summary>
### 🚨 IMPORTANT
### This tool is for allowed environment only!
#### ✅ APPROVED USE CASES
> CTF (Capture The Flag) competitions <br>
> Authorized penetration testing <br>
> Security research and laboratory environments <br>
> Systems you own or have explicit permission to test <br>
#### 🚫 PROHIBITED USE
> Unauthorized access to any system <br>
> Illegal or malicious activities <br>
> Production systems without explicit authorization <br>
> Networks you do not own or control
### ⚠️ DISCLAIMER
```
I take no responsibility for misuse, illegal activity, or unauthorized use.
Any and all consequences are the sole responsibility of the user.
```
</details>
<details>
<summary><h2>⫻ License</h2></summary>
### MIT License
```
MIT License
Copyright (c) 2026 EVA - Exploit Vector Agent
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.
```
</details>
<div align="center">
## ❤️ Support
### if you enjoy the project and want to support future development:
[](https://github.com/ARCANGEL0/EVA)
[](https://github.com/ARCANGEL0)
<br>
<a href='https://ko-fi.com/J3J7WTYV7' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi3.png?v=6' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>
<br>
<strong>Hack the world. Byte by Byte.</strong> ⛛ <br>
𝝺𝗿𝗰𝗮𝗻𝗴𝗲𝗹𝗼 @ 2026
**[[ꋧ]](#-𝝣𝗩𝝠)**
</div>
---
*⚠️ Remember: With great power comes great responsibility. Use this tool ethically and legally.*
| text/markdown | ARCANGEL0 | null | null | null | MIT | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"colorama>=0.4.6",
"openai>=1.0.0",
"requests>=2.31.0"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-21T04:34:21.284654 | eva_exploit-3.4.2.tar.gz | 58,265 | f5/90/197171001ea3b9a9f69c6c54cbc182e206fb2e036b2ec01fc5399ef01aea/eva_exploit-3.4.2.tar.gz | source | sdist | null | false | 4b9a28f4259cebd96b296503eddce403 | 16c14fea48bad6af7ba1aa9a9b50bd60d7340303a8406a431db2057fb218f1b8 | f590197171001ea3b9a9f69c6c54cbc182e206fb2e036b2ec01fc5399ef01aea | null | [] | 247 |
2.4 | pysilica | 0.8.15 | A command line tool for creating workspaces for agents on top of piku | # Silica: Multi-Workspace Management for Agents
Silica is a command-line tool for creating and managing agent workspaces on top of piku.
## Installation
### Quick Install
For systems with Python 3.11+:
```bash
# Using uv (recommended)
uv pip install pysilica
playwright install chromium # Install browser for web development tools
# Using pip
pip install pysilica
playwright install chromium # Install browser for web development tools
```
### Raspberry Pi Deployment
Silica automatically handles Python 3.11 installation on remote Raspberry Pi systems during workspace creation. The deployment process:
- Detects Raspberry Pi hardware
- Installs Python 3.11 via pyenv if needed
- Sets up virtual environment
- Installs Silica and dependencies
- Verifies the installation
For detailed deployment information, see the [Raspberry Pi Deployment Guide](docs/remote/RASPBERRY_PI_DEPLOYMENT.md).
**Note**: The package name is `pysilica` but the CLI command and import name is `silica`.
### Requirements
- **Python**: 3.11 or higher (required)
- **Package Manager**: `uv` (recommended) or `pip`
- **Playwright Browser**: Required for web development tools (installed via `playwright install chromium`)
- **OpenCV**: Optional, required for webcam snapshot capabilities (installed via `pip install opencv-python`)
- **ripgrep**: Optional but recommended for enhanced file search performance
For complete installation instructions, see [docs/INSTALLATION.md](docs/remote/INSTALLATION.md).
#### Optional: Install ripgrep for enhanced search performance
```bash
# macOS
brew install ripgrep
# Ubuntu/Debian
sudo apt install ripgrep
# Windows (chocolatey)
choco install ripgrep
```
Ripgrep provides faster file searching and is automatically used by the memory system when available.
## What's New: Multi-Workspace Support
Silica now supports managing multiple concurrent workspaces from the same repository. This allows you to:
1. Create and maintain multiple agent workspaces with different configurations
2. Switch between workspaces easily without having to recreate them
3. Track configurations for all workspaces in a single repository
## Key Features
- **Multiple Agent Support**: Support for different AI coding agents with YAML-based configuration
- **Workspace Management**: Create, list, and manage multiple agent workspaces
- **Default Workspace**: Set a preferred workspace as default for easier command execution
- **Immutable Workspaces**: Each workspace is tied to a specific agent type - create new workspaces for different agents
## 🤖 Integrated Agent
Silica is tightly integrated with **heare-developer (hdev)**, an autonomous coding agent that includes:
- Autonomous engineering with the `--dwr` (Do What's Required) flag
- Configurable personas for different coding styles
- Integration with Claude for AI assistance
- Web search capabilities via Brave Search API
- GitHub integration for repository management
The agent is automatically installed when creating workspaces and configured for optimal performance.
## Usage
### Creating Workspaces
```bash
# Create a default workspace named 'agent' with heare-developer
silica create
# Create a workspace with a custom name
silica create -w assistant
# Create workspace for a specific project
silica create -w my-project
```
### Managing Workspaces
```bash
# List all configured workspaces
silica workspace list
# View the current default workspace
silica workspace get-default
# Set a different workspace as default
silica workspace set-default assistant
```
### Working with Specific Workspaces
Most commands accept a `-w/--workspace` flag to specify which workspace to target:
```bash
# Sync a specific workspace
silica sync -w assistant
# Sync with cache clearing to ensure latest versions
silica sync -w assistant --clear-cache
# Check status of a specific workspace
silica status -w assistant
# Enter a specific workspace's agent session
silica remote enter -w assistant
# Send a message to the workspace's agent
silica tell "Please analyze this code" -w assistant
```
### Configuration Management
```bash
# View current configuration
silica config list
# Set configuration values
silica config set key=value
# Run interactive setup wizard
silica config setup
```
### Destroying Workspaces
```bash
# Destroy a specific workspace
silica destroy -w assistant
```
## Configuration
Silica stores workspace configurations in `.silica/config.yaml` using a nested structure:
```yaml
default_workspace: agent
workspaces:
agent:
piku_connection: piku
app_name: agent-repo-name
branch: main
agent_type: hdev
agent_config:
flags: []
args: {}
assistant:
piku_connection: piku
app_name: assistant-repo-name
branch: feature-branch
agent_type: hdev
agent_config:
flags: ["--persona", "code_reviewer"]
args: {}
```
## Development
### Running Tests
```bash
# Run all tests
pytest
# Run only fast tests (excludes slow integration tests)
pytest -m "not slow"
# Run with verbose output and show slowest tests
pytest -v --durations=10
```
The test suite includes markers for different test types:
- `slow`: Integration tests that take longer to run (tmux operations, subprocess timeouts)
- `integration`: Tests requiring external resources
- `safe`: Tests with no side effects
For faster development iteration, use `pytest -m "not slow"` to run only the fast tests (~43s vs ~82s for the full suite).
## Compatibility
This update maintains backward compatibility with existing silica workspaces. When you run commands with the updated version:
1. Existing workspaces are automatically migrated to the new format
2. The behavior of commands without specifying a workspace remains the same
3. Old script implementations that expect workspace-specific configuration will continue to work
| text/markdown | null | Sean Fitzgerald <sean@fitzgeralds.me> | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"cyclopts>=2.0.0",
"rich>=13.3.0",
"requests>=2.28.0",
"pyyaml>=6.0",
"gitpython>=3.1.0",
"flask>=3.0.0",
"filelock>=3.13.1",
"dotenv>=0.9.9",
"anthropic>=0.62.0",
"pydantic>=2.11.7",
"aiofiles>=24.1.0",
"pathspec>=0.12.1",
"prompt-toolkit>=3.0.51",
"bs4>=0.0.2",
"markdownify>=1.2.0",
"brave-search-python-client>=0.4.27",
"google-api-python-client>=2.178.0",
"google-auth-oauthlib>=1.2.2",
"markdown>=3.8.2",
"fastapi>=0.116.1",
"sqlalchemy>=2.0.43",
"sqlalchemy-orm>=1.2.10",
"uvicorn>=0.35.0",
"croniter>=6.0.0",
"python-multipart>=0.0.20",
"pydantic-settings>=2.0.0",
"heare-ids>=0.1.3",
"psutil>=5.9.0",
"structlog>=24.0.0",
"setuptools-scm>=9.2.0",
"playwright>=1.40.0",
"boto3>=1.34.0",
"httpx>=0.27.0",
"opencv-python>=4.8.0",
"bashlex>=0.18",
"mcp>=1.0.0",
"keyring>=24.0.0",
"deaddrop>=0.1.0",
"pre-commit>=4.2.0; extra == \"dev\"",
"pytest>=8.3.5; extra == \"dev\"",
"pytest-asyncio>=1.1.0; extra == \"dev\"",
"pytest-cov>=6.0.0; extra == \"dev\"",
"ruff>=0.13.0; extra == \"dev\"",
"moto[s3]<5.1.20,>=5.0.0; extra == \"dev\"",
"pytest-mock>=3.15.1; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:33:56.542824 | pysilica-0.8.15.tar.gz | 10,364,904 | 4b/24/466232d4fe0bf0996390261a7d6c55353e0597989ca346ca24b4fd694211/pysilica-0.8.15.tar.gz | source | sdist | null | false | 3d9887105abb6cbf4ef7cfc84a4980e7 | d4753257c92378e6957724d7a4b991b1c7021223b46052fd6bef1e0f6820171f | 4b24466232d4fe0bf0996390261a7d6c55353e0597989ca346ca24b4fd694211 | null | [] | 238 |
2.4 | zbToolLib | 2.0.8 | zb工具库 | # [zb工具库（zbToolLib）](https://ianzb.github.io/project/zbToolLib.html)
zb工具库（zbToolLib）是一个Python工具库，提供了文件处理、网络请求、日志记录等功能，目前用于zb小程序等个人Python项目中。
## 链接
[Github](https://github.com/Ianzb/zbToolLib/)
[PyPi](https://pypi.org/project/zbToolLib/)
## 历史
2024-11-02：0.0.1：随着zb小程序5.0.0版本的重构，zbToolLib相关功能独立。
2025-01-13：1.0.0：首次尝试于PyPi发布。
2025-01-15：1.1.0：重新发布。
2025-01-29：1.2.0b1：整理代码，删除日志模块配置，整理代码，删除多线程下载模块DownloadKit相关功能，重写多线程下载模块，尝试适配MacOS和Linux系统。
2025-02-12：1.2.0：完善docstring。
2025-02-17：1.2.2：post模块支持自动识别data类型数据，优化isUrl和getFileNameFromUrl，新增splitUrl。
2025-02-19：1.2.3：修复showFile。
2025-02-26：1.2.4：post模块改为手动填写数据类型。
2025-03-01：1.2.5b1：添加线程池装饰器。
2025-03-08：1.2.5：修复post参数问题。
2025-04-13：1.2.6.1：移除ssl验证，新增运行文件功能，优化展示文件功能，优化import代码。
2025-05-02：1.2.7：多线程下载支持等待所有任务结束。
2025-05-03：1.2.8.2：修复多线程下载进度条部分时候除以零报错的Bug，添加下载失败后自动删除文件的功能，更改日志中的一个错字。
2025-05-17：2.0.0b3：新增并重命名多个函数。
2025-05-23：2.0.0b4：修改magic库逻辑。
2025-06-01：2.0.0：修复showFile斜杠处理缺失的Bug。
2025-06-07：2.0.1.2：修复clearEscapeCharaters无返回值的Bug，修复fileSize错误的问题，修复复制文件时创建文件异常的Bug。
2025-06-15：2.0.2：取消SSL验证。
2025-06-16：2.0.3：重写Magic相关模块，迁移至puramagic库。
2025-08-30：2.0.4：新增getInfo。
2025-10-03：2.0.5：DownloadSession支持暂停。
2025-10-04：2.0.6.1：DownloadSession完善状态码。
2025-12-06：2.0.7：尝试隐藏系统错误弹窗。
2026-02-21：2.0.8：更新系统路径方法，不再是单独的函数。
| text/markdown | null | Ianzb <93322252@qq.com> | null | Ianzb <93322252@qq.com> | MIT License | zb, Ianzb, tool, lib | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.13",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Operating System :: Microsoft :: Windows",
"Operating System :: MacOS :: MacOS X",
"Operating System :: POSIX :: Linux"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"send2trash>=2.1.0",
"requests>=2.32.5",
"winshell>=0.6; sys_platform == \"win32\"",
"pywin32>=311; sys_platform == \"win32\"",
"puremagic>=2.0.0"
] | [] | [] | [] | [
"Repository, https://github.com/Ianzb/zbToolLib/"
] | twine/6.2.0 CPython/3.13.9 | 2026-02-21T04:32:57.132630 | zbtoollib-2.0.8-py3-none-any.whl | 13,022 | f9/37/3f4eef1283a6eaba3461b2a92b06b565f83edcd5699ee850bb04ebf16525/zbtoollib-2.0.8-py3-none-any.whl | py3 | bdist_wheel | null | false | 965b0769a080716434c14da83c6c164a | d12a259232860f78ae0d42153ad13a79ef175dfef3d53f25356a9d351bf2afdc | f9373f4eef1283a6eaba3461b2a92b06b565f83edcd5699ee850bb04ebf16525 | null | [
"LICENSE"
] | 0 |
2.4 | tappi | 0.9.0 | Lightweight CDP browser control for Python — with an AI agent that can browse, read PDFs, manage files, and automate tasks. | # tappi
**Your own AI agent that controls a real browser and manages files — running entirely on your machine.**
🌐 **[tappi.synthworx.com](https://tappi.synthworx.com)** — Official home page & docs. Tappi is and will always be fully open source (MIT).
Give it a task in plain English. It opens your browser, navigates pages, clicks buttons, fills forms, reads content, creates PDFs, updates spreadsheets, and schedules recurring jobs. All your logins and cookies carry over. Everything stays local — your data never leaves your machine.
Think of it as a personal automation assistant with two superpowers: **browser control** and **file management**, sandboxed to one directory. Secure enough for work. Powerful enough to replace most browser automation scripts you've ever written.
### Why tappi?
Every AI browser tool today pays a tax — either in tokens or in capability:
- **Screenshot-based agents** (Operator, Computer Use) send full page images to the LLM. The model squints at pixels, guesses coordinates, and prays it clicks the right button. A single interaction can burn 5-10K tokens on vision alone.
- **DOM/accessibility tree tools** (Playwright MCP, browser tools) dump the entire page structure into context. A single Reddit page can produce 50K+ tokens of nested elements. The LLM reads a novel just to find a button.
Tappi does neither. It indexes interactive elements into a compact numbered list:
```
[0] (link) Homepage → https://github.com/
[1] (button) Sign in
[2] (link) Explore → /explore
[3] (button) Submit Order
```
The LLM says `click 3`. Done. **~200 tokens instead of 5-50K.** That's the difference.
- **10x more token-efficient** than both screenshot-based and DOM-dump approaches. Structured element lists give the model exactly what it needs — nothing more.
- **Better LLM decisions.** Numbered elements with semantic labels (`[3] (button) Submit Order`) are unambiguous. No hallucinated CSS selectors. No coordinate guessing. No wading through thousands of DOM nodes.
- **Real browser, real sessions.** Connects to Chrome via CDP — your saved logins, cookies, and extensions are all there. Log in once, automate forever.
- **Sandboxed by design.** One workspace directory. One browser. No filesystem access beyond the sandbox. Safe for corporate environments where you can't install full automation platforms.
- **Works everywhere.** Linux, macOS, Windows. Python 3.10+. Single `pip install`.
```bash
pip install tappi # Everything: CDP + MCP server + AI agent
```
---
## Table of Contents
- [Installation](#installation)
- [Quick Start](#quick-start)
- [AI Agent Mode](#ai-agent-mode) ← **New**
- [Web UI](#web-ui) ← **New**
- [Tutorial: Your First Automation](#tutorial-your-first-automation)
- [How It Works](#how-it-works)
- [Python Library](#using-as-a-python-library)
- [CLI Reference](#cli-reference)
- [Profiles](#profiles)
- [Shadow DOM Support](#shadow-dom-support)
- [MCP Server](#mcp-server) ← **New**
- [FAQ](#faq)
- [License](#license)
---
## Installation
### One-Line Installer (recommended)
Downloads Python if needed, creates a virtual environment, installs tappi, and drops a **"Launch tappi"** shortcut on your Desktop. Inspect the scripts first if you like — they're [in the repo](install/).
**macOS:**
```bash
curl -fsSL https://raw.githubusercontent.com/shaihazher/tappi/main/install/install-macos.sh | bash
```
**Linux (Debian/Ubuntu, Fedora, Arch):**
```bash
curl -fsSL https://raw.githubusercontent.com/shaihazher/tappi/main/install/install-linux.sh | bash
```
**Windows (PowerShell):**
```powershell
irm https://raw.githubusercontent.com/shaihazher/tappi/main/install/install-windows.ps1 | iex
```
After install, double-click **"Launch tappi"** on your Desktop — it starts the browser, launches the web UI, and opens it automatically. Pick your AI provider and API key in the Settings page on first launch. See the [Web UI Tutorial](docs/blog/tappi-web-ui-tutorial.md) for a visual walkthrough.
### Manual Install (with venv)
If you prefer to set things up yourself. Requires Python 3.10+.
<details>
<summary><b>macOS</b></summary>
```bash
# Install Python 3.13 (skip if you already have 3.10+)
brew install python@3.13
# Create and activate a virtual environment
python3.13 -m venv ~/.tappi-venv
source ~/.tappi-venv/bin/activate
# Install tappi
pip install --upgrade pip
pip install tappi
# Verify
bpy --version
```
To auto-activate on every new terminal, add to your `~/.zshrc` (or `~/.bash_profile`):
```bash
source ~/.tappi-venv/bin/activate
```
</details>
<details>
<summary><b>Linux (Debian/Ubuntu)</b></summary>
```bash
# Install Python 3.13 and venv (skip if you already have 3.10+)
sudo apt update
sudo apt install -y python3 python3-pip python3-venv
# Create and activate a virtual environment
python3 -m venv ~/.tappi-venv
source ~/.tappi-venv/bin/activate
# Install tappi
pip install --upgrade pip
pip install tappi
# Verify
bpy --version
```
To auto-activate on every new terminal, add to your `~/.bashrc`:
```bash
source ~/.tappi-venv/bin/activate
```
</details>
<details>
<summary><b>Linux (Fedora/RHEL)</b></summary>
```bash
# Install Python 3.13 (skip if you already have 3.10+)
sudo dnf install -y python3 python3-pip
# Create and activate a virtual environment
python3 -m venv ~/.tappi-venv
source ~/.tappi-venv/bin/activate
# Install tappi
pip install --upgrade pip
pip install tappi
# Verify
bpy --version
```
</details>
<details>
<summary><b>Linux (Arch)</b></summary>
```bash
# Install Python (skip if you already have 3.10+)
sudo pacman -Sy python python-pip
# Create and activate a virtual environment
python -m venv ~/.tappi-venv
source ~/.tappi-venv/bin/activate
# Install tappi
pip install --upgrade pip
pip install tappi
# Verify
bpy --version
```
</details>
<details>
<summary><b>Windows</b></summary>
```powershell
# Install Python 3.13 (skip if you already have 3.10+)
winget install Python.Python.3.13
# Create and activate a virtual environment
python -m venv $env:USERPROFILE\.tappi-venv
& "$env:USERPROFILE\.tappi-venv\Scripts\Activate.ps1"
# Install tappi
pip install --upgrade pip
pip install tappi
# Verify
bpy --version
```
To auto-activate on every new terminal, add to your PowerShell profile (`notepad $PROFILE`):
```powershell
. "$env:USERPROFILE\.tappi-venv\Scripts\Activate.ps1"
```
</details>
### Quick Install (no venv)
If you just want to get going and don't care about virtual environments:
```bash
pip install tappi
```
---
## Quick Start
If you used the one-line installer, just double-click **"Launch tappi"** on your Desktop. Done.
From the terminal:
```bash
# Launch browser + web UI (opens http://127.0.0.1:8321)
bpy launch && bpy serve
# Or use the CLI agent directly
bpy setup # one-time: pick provider + API key
bpy launch # start the browser
bpy agent "Go to github.com and find today's trending Python repos"
```
---
## AI Agent Mode
The agent is an LLM with 6 tools that can browse the web, read/write files, create PDFs, manage spreadsheets, run shell commands, and schedule recurring tasks — all within a sandboxed workspace directory.
### Setup
```bash
bpy setup
```
The wizard walks you through:
1. **LLM Provider** — OpenRouter, Anthropic, Claude Max (OAuth), OpenAI, AWS Bedrock, Azure, Google Vertex
2. **API Key** — paste your key (or OAuth token for Claude Max)
3. **Model** — defaults per provider, fully configurable
4. **Workspace** — sandboxed directory for all file operations
5. **Browser Profile** — which browser profile the agent uses
6. **Shell Access** — toggle on/off
All config lives in `~/.tappi/config.json`.
### Providers
| Provider | Auth | Status |
|----------|------|--------|
| **OpenRouter** | API key | ✅ Ready |
| **Anthropic** | API key | ✅ Ready |
| **Claude Max (OAuth)** | OAuth token (`sk-ant-oat01-...`) | ✅ Ready |
| **OpenAI** | API key | ✅ Ready |
| **AWS Bedrock** | AWS credentials | ✅ Ready (via LiteLLM) |
| **Azure OpenAI** | API key + endpoint | ✅ Ready (via LiteLLM) |
| **Google Vertex AI** | Service account | ✅ Ready (via LiteLLM) |
All providers work through [LiteLLM](https://github.com/BerriAI/litellm) — one interface, any model.
#### Claude Max (OAuth) — Use Your Subscription
If you have a Claude Pro/Max subscription ($20-200/mo), you can use your **OAuth token** instead of paying per-API-call. This is the same token Claude Code uses.
```bash
bpy setup
# Choose "Claude Max (OAuth)"
# Paste your token: sk-ant-oat01-...
```
**Where to find your token:**
- If you use Claude Code: check your credentials file or environment
- The token format is `sk-ant-oat01-...` (different from API keys which are `sk-ant-api03-...`)
- It works as a drop-in replacement — no proxy, no special config
### CLI Usage
#### Interactive mode
```bash
bpy agent
```
```
tappi agent (type 'quit' to exit, 'reset' to clear)
You: Go to hacker news and find the top post about AI
🔧 browser → launch
🔧 browser → open
🔧 browser → elements
🔧 browser → text
Agent: The top AI-related post on Hacker News right now is "GPT-5 Released"
with 342 points. It links to openai.com/blog/gpt5 and the discussion has
127 comments. Want me to read the article or the comments?
```
#### One-shot mode
```bash
bpy agent "Create a PDF report of today's weather in Houston"
```
The agent figures out the steps: open a weather site → extract data → create HTML → convert to PDF → save to workspace.
### Tools
The agent has 6 tools, each exposed as a JSON schema the LLM calls natively:
| Tool | What it does |
|------|-------------|
| **browser** | Navigate, click, type, read pages, screenshots, tab management. Uses your real browser with saved logins. |
| **files** | Read, write, list, move, copy, delete files — sandboxed to workspace. |
| **pdf** | Read text from PDFs (PyMuPDF), create PDFs from HTML (WeasyPrint). |
| **spreadsheet** | Read/write CSV and Excel (.xlsx) files, create new ones with headers. |
| **shell** | Run shell commands (cwd = workspace). Can be disabled in settings. |
| **cron** | Schedule recurring tasks with cron expressions or intervals. |
### How the Agent Loop Works
```
User message
↓
┌──────────────────────────┐
│ LLM (via LiteLLM) │ ◄── Sees all 6 tools as JSON schemas
│ Decides what to do │
└──────────┬───────────────┘
│
▼
┌─ Tool calls? ──┐
│ │
Yes No → Return text response
│
▼
Execute each tool call
│
▼
Append results to conversation
│
▼
Loop back to LLM ────────────► (max 50 iterations)
```
The loop is synchronous — each tool call blocks until complete. No timeouts. The LLM sees tool results and decides the next step, just like a human would.
### Cron (Scheduled Tasks)
Tell the agent to schedule recurring tasks:
```
You: Schedule a job to check trending repos on GitHub every morning at 9 AM
Agent: Done. Created job "GitHub Trends" with schedule "0 9 * * *".
```
Jobs are stored in `~/.tappi/jobs.json` and persist across restarts. When `bpy serve` is running, APScheduler fires each job in its own agent session.
```bash
# Via CLI
bpy agent "List my scheduled jobs"
bpy agent "Pause the GitHub Trends job"
bpy agent "Remove job abc123"
```
---
## Web UI
```bash
bpy serve # http://127.0.0.1:8321
bpy serve --port 9000 # custom port
```
📖 **[Full visual walkthrough →](docs/blog/tappi-web-ui-tutorial.md)**
The web UI has 4 sections:
### 💬 Chat
Full chat interface with live tool call visibility. As the agent works, you see each tool call and its result in real-time via WebSocket.
### 🌍 Browser Profiles
View and create browser profiles. Each profile has its own Chrome sessions (cookies, logins) and CDP port. Create profiles for different use cases — work, personal, social media.
### ⏰ Scheduled Jobs
View all cron jobs with their schedule, status (active/paused), and task description. Jobs are created via chat ("schedule a task to...").
### ⚙️ Settings
- **Model** — change the LLM model
- **Browser Profile** — select which profile the agent uses
- **Shell Access** — enable/disable shell commands
- **Workspace** — view the sandboxed directory
> **Note:** Provider and API key changes require `bpy setup` (CLI) — these aren't exposed in the web UI for security.
---
## Tutorial: Your First Automation
### Step 1: Launch the browser
```bash
bpy launch
```
```
✓ Chrome launched on port 9222
Profile: ~/.tappi/profiles/default
⚡ First launch — a fresh Chrome window opened.
Log into the sites you want to automate (Gmail, GitHub, etc.).
Those sessions will persist for all future launches.
```
**First time only:** A fresh Chrome window opens. Log into the websites you want to automate. Close the window when done. Your sessions are saved in the profile.
### Step 2: Control it
```bash
bpy open github.com # Navigate
bpy elements # See what's clickable
bpy click 3 # Click element [3]
bpy type 5 "hello world" # Type into element [5]
bpy text # Read the page
bpy screenshot page.png # Screenshot
```
Every interactive element gets a number. Use that number with `click` and `type`.
---
## How It Works
### The connection
```
┌─────────────┐ CDP (WebSocket) ┌──────────────────┐
│ tappi │ ◄──────────────────────► │ Chrome/Chromium │
│ (your code) │ localhost:9222 │ (your sessions) │
└─────────────┘ └──────────────────┘
```
`bpy launch` starts Chrome with `--remote-debugging-port=9222` and a persistent `--user-data-dir`. All commands connect to that port via WebSocket.
### Real mouse events
`click` uses CDP's `Input.dispatchMouseEvent` — real mouse presses, not `.click()`. Works with React, Vue, Angular, and every framework.
### Shadow DOM piercing
The element scanner recursively enters every shadow root. Reddit, GitHub, Salesforce, Angular Material — all work automatically.
### Framework-aware typing
`type` dispatches proper `input` and `change` events using React's native value setter. SPAs with controlled components get the value update correctly.
---
## Using as a Python Library
```python
from tappi import Browser
Browser.launch() # Start Chrome
b = Browser() # Connect
b.open("https://github.com")
elements = b.elements() # List interactive elements
b.click(1) # Click by index
b.type(2, "search query") # Type into input
text = b.text() # Read visible text
b.screenshot("page.png") # Screenshot
b.upload("~/file.pdf") # Upload file
```
### Profile management
```python
from tappi.profiles import create_profile, list_profiles, get_profile
create_profile("work") # → port 9222
create_profile("personal") # → port 9223
# Run multiple simultaneously
work = get_profile("work")
Browser.launch(port=work["port"], user_data_dir=work["path"])
b = Browser(f"http://127.0.0.1:{work['port']}")
```
### Agent as a library
```python
from tappi.agent.loop import Agent
agent = Agent(
browser_profile="default",
on_tool_call=lambda name, params, result: print(f"🔧 {name}"),
)
response = agent.chat("Go to github.com and find trending repos")
print(response)
# Multi-turn
response = agent.chat("Now check the first one and summarize the README")
print(response)
# Reset conversation
agent.reset()
```
---
## CLI Reference
### Agent Commands
| Command | Description |
|---------|-------------|
| `bpy setup` | Configure LLM provider, workspace, browser |
| `bpy agent [message]` | Chat with the agent (interactive or one-shot) |
| `bpy serve [--port 8321]` | Start the web UI |
### Browser Commands
| Command | Description |
|---------|-------------|
| `bpy launch [name]` | Start Chrome with a named profile |
| `bpy launch new [name]` | Create a new profile |
| `bpy launch list` | List all profiles |
| `bpy launch --default <name>` | Set the default profile |
### Navigation
| Command | Description |
|---------|-------------|
| `bpy open <url>` | Navigate to URL |
| `bpy url` | Print current URL |
| `bpy back` / `forward` / `refresh` | History navigation |
### Interaction
| Command | Description |
|---------|-------------|
| `bpy elements [selector]` | List interactive elements (numbered) |
| `bpy click <index>` | Click element by number |
| `bpy type <index> <text>` | Type into element |
| `bpy upload <path> [selector]` | Upload file |
### Content
| Command | Description |
|---------|-------------|
| `bpy text [selector]` | Extract visible text |
| `bpy html <selector>` | Get element HTML |
| `bpy eval <js>` | Run JavaScript |
| `bpy screenshot [path]` | Save screenshot |
### Other
| Command | Description |
|---------|-------------|
| `bpy tabs` / `tab <n>` / `newtab` / `close` | Tab management |
| `bpy scroll <dir> [px]` | Scroll the page |
| `bpy wait <ms>` | Wait (for scripts) |
---
## Profiles
Each profile is a separate Chrome session with its own logins, cookies, and CDP port.
```bash
bpy launch # Default profile (port 9222)
bpy launch new work # Create "work" (port 9223)
bpy launch work # Launch it
bpy launch list # See all profiles
bpy launch --default work # Set default
bpy launch delete old # Remove a profile
# Run multiple simultaneously
bpy launch # Terminal 1: default on 9222
bpy launch work # Terminal 2: work on 9223
CDP_URL=http://127.0.0.1:9223 bpy tabs # Control work profile
```
Profiles live at `~/.tappi/profiles/<name>/`. Config at `~/.tappi/config.json`.
---
## Shadow DOM Support
tappi automatically pierces shadow DOM boundaries. No configuration needed.
```bash
bpy open reddit.com
bpy elements # Finds elements inside shadow roots
bpy click 5 # Works normally
```
---
## Environment Variables
| Variable | Description | Default |
|----------|-------------|---------|
| `CDP_URL` | CDP endpoint URL | `http://127.0.0.1:9222` |
| `NO_COLOR` | Disable colored output | (unset) |
| `ANTHROPIC_API_KEY` | Anthropic/Claude Max key | (from config) |
| `OPENROUTER_API_KEY` | OpenRouter key | (from config) |
| `OPENAI_API_KEY` | OpenAI key | (from config) |
---
## MCP Server
tappi includes a built-in MCP (Model Context Protocol) server, so you can use it with **Claude Desktop**, **Cursor**, **Windsurf**, **OpenClaw**, or any MCP-compatible AI agent.
### Claude Desktop — One-Click Install (.mcpb)
The easiest way to add tappi to Claude Desktop is the **`.mcpb` bundle** — a single file that installs everything:
1. Download [`tappi-0.5.1.mcpb`](https://github.com/shaihazher/tappi/releases/latest) from the latest release
2. Double-click it — Claude Desktop installs the extension automatically
3. Start Chrome with `tappi launch` or `--remote-debugging-port=9222`
4. Ask Claude to browse the web
No `pip install`. No config editing. No Python on your PATH. The bundle includes all source code and dependencies — Claude Desktop manages the runtime via `uv`.
> **See it in action:** [Real Claude Desktop conversation using tappi MCP](https://claude.ai/share/c8a162bd-d35b-4db6-a704-c3bc57ee0498)
### Manual Setup (pip)
If you prefer manual installation or use other MCP clients:
```bash
pip install tappi
```
Add to your `claude_desktop_config.json`:
```json
{
"mcpServers": {
"tappi": {
"command": "tappi",
"args": ["mcp"],
"env": {
"CDP_URL": "http://127.0.0.1:9222"
}
}
}
}
```
**Don't want to install anything?** Use `uvx` (comes with [uv](https://docs.astral.sh/uv/)):
```json
{
"mcpServers": {
"tappi": {
"command": "uvx",
"args": ["tappi", "mcp"],
"env": {
"CDP_URL": "http://127.0.0.1:9222"
}
}
}
}
```
**Prefer npm?** There's a thin wrapper that delegates to the Python server:
```bash
npx tappi-mcp
```
Claude Desktop config with npx:
```json
{
"mcpServers": {
"tappi": {
"command": "npx",
"args": ["tappi-mcp"],
"env": {
"CDP_URL": "http://127.0.0.1:9222"
}
}
}
}
```
### Cursor / Windsurf
Same config format — add the `tappi` server to your MCP settings with the command above.
### OpenClaw
tappi is available as an [OpenClaw](https://openclaw.ai) skill on [ClawHub](https://clawhub.com):
```bash
clawhub install tappi
```
### HTTP/SSE Transport
For MCP clients that prefer HTTP instead of stdio:
```bash
tappi mcp --sse # default: 127.0.0.1:8377
tappi mcp --sse --port 9000 # custom port
```
### Available Tools
The MCP server exposes 23 tools:
| Tool | Description |
|------|-------------|
| `tappi_open` | Navigate to a URL |
| `tappi_elements` | List interactive elements (numbered, shadow DOM piercing) |
| `tappi_click` | Click element by index |
| `tappi_type` | Type into element by index |
| `tappi_text` | Extract visible page text |
| `tappi_eval` | Run JavaScript in page context |
| `tappi_screenshot` | Capture page screenshot |
| `tappi_tabs` | List open tabs |
| `tappi_tab` | Switch tab |
| `tappi_scroll` | Scroll page |
| `tappi_upload` | Upload file (bypasses OS dialog) |
| `tappi_click_xy` | Click at coordinates (cross-origin iframes) |
| `tappi_iframe_rect` | Get iframe bounding box |
| ... and 10 more | `newtab`, `close`, `url`, `back`, `forward`, `refresh`, `html`, `hover_xy`, `drag_xy`, `wait` |
### How It's Different
Unlike Playwright MCP or browser tool ARIA snapshots, tappi's MCP server:
- **Connects to your existing Chrome** — all sessions, cookies, extensions carry over
- **Pierces shadow DOM** — Gmail, Reddit, GitHub all work natively
- **Returns compact indexed output** — `[3] (button) Submit` instead of a 50K-token accessibility tree
- **Uses 3-10x fewer tokens** per interaction
- **No headless browser** — runs in your real Chrome, invisible to bot detection
### Prerequisites
Start Chrome with remote debugging enabled:
```bash
# Option 1: tappi launch (manages profiles for you)
tappi launch
# Option 2: Manual
google-chrome --remote-debugging-port=9222
```
Set `CDP_URL` in your MCP config to point to your Chrome instance (default: `http://127.0.0.1:9222`).
---
## FAQ
**Q: What's the difference between `bpy agent` and `bpy` commands?**
`bpy agent` talks to an LLM that decides what to do. `bpy click 3` directly executes a browser command. Use agent mode for complex multi-step tasks; use direct commands for scripting.
**Q: Can I use my Claude Max subscription instead of paying per-API-call?**
Yes. Choose "Claude Max (OAuth)" during `bpy setup` and paste your OAuth token (`sk-ant-oat01-...`). Same token Claude Code uses.
**Q: Do I need to log in every time?**
No. Log in once during your first `bpy launch`. Sessions persist in the profile directory.
**Q: What browsers are supported?**
Chrome, Chromium, Brave, Microsoft Edge — anything Chromium-based with CDP support.
**Q: Does it work headless?**
Yes. `bpy launch --headless` runs without a visible window. Log in with a visible window first to set up sessions.
**Q: Is my data safe?**
File operations are sandboxed to your workspace directory. The agent cannot access files outside it. Shell access can be disabled. API keys are stored locally in `~/.tappi/config.json`.
**Q: How is this different from Selenium/Playwright?**
| | tappi | Selenium | Playwright |
|---|:---:|:---:|:---:|
| Session reuse | ✅ | ❌ | Partial |
| AI agent | ✅ | ❌ | ❌ |
| Shadow DOM | ✅ | ❌ | ❌ |
| Dependencies | 1 (core) | Heavy | Heavy |
| Install size | ~100KB | ~50MB | ~200MB+ |
---
## Architecture
```
tappi/
├── tappi/
│ ├── core.py # CDP engine (Phase 1)
│ ├── cli.py # bpy CLI
│ ├── profiles.py # Named profile management
│ ├── js_expressions.py # Injected JS for element scanning
│ ├── agent/
│ │ ├── loop.py # Agentic while-loop (LiteLLM)
│ │ ├── config.py # Provider/workspace/model config
│ │ ├── setup.py # Interactive setup wizard
│ │ └── tools/
│ │ ├── browser.py # Browser tool (wraps core.py)
│ │ ├── files.py # Sandboxed file ops
│ │ ├── pdf.py # PDF read (PyMuPDF) + create (WeasyPrint)
│ │ ├── spreadsheet.py # CSV + Excel (openpyxl)
│ │ ├── shell.py # Sandboxed shell execution
│ │ └── cron.py # APScheduler cron jobs
│ └── server/
│ └── app.py # FastAPI web UI + API
└── pyproject.toml
```
---
## Blog Posts
- 🏆 [Tappi Is the Most Token-Efficient Browser Tool for AI Agents](https://dev.to/azeruddin_sheikh_f75230b5/tappi-is-the-most-token-efficient-browser-tool-for-ai-agents-nothing-else-comes-close-33gk) — Deep competitive analysis with live benchmarks vs Agent-Browser, Playwright CLI, and more
- 🚀 [Every AI Browser Tool Is Broken Except One](https://dev.to/azeruddin_sheikh_f75230b5/every-ai-browser-tool-is-broken-except-one-33i0) — The original benchmark (59K tokens 3/3 ✅ vs 252K for browser tools)
- 🔌 [Tappi MCP Is Live](https://dev.to/azeruddin_sheikh_f75230b5/tappi-mcp-is-live-give-claude-desktop-a-real-browser-1kk4) — MCP server for Claude Desktop
- 🖥️ [Tappi Web UI Tutorial](https://dev.to/azeruddin_sheikh_f75230b5/tappi-web-ui-the-complete-setup-guide-4o5p) — Visual walkthrough
---
## License
MIT
| text/markdown | null | Azeruddin Sheik <shaihazher@gmail.com> | null | null | null | agent, ai, automation, browser, cdp, chrome, llm | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Internet :: WWW/HTTP :: Browsers",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Software Development :: Testing"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"apscheduler>=3.10.0",
"boto3>=1.28.0",
"fastapi>=0.110.0",
"litellm>=1.40.0",
"mcp>=1.0",
"openpyxl>=3.1.0",
"pymupdf>=1.24.0",
"uvicorn[standard]>=0.27.0",
"weasyprint>=62.0",
"websockets>=12.0"
] | [] | [] | [] | [
"Homepage, https://github.com/shaihazher/tappi",
"Repository, https://github.com/shaihazher/tappi",
"Issues, https://github.com/shaihazher/tappi/issues"
] | uv/0.9.28 {"installer":{"name":"uv","version":"0.9.28","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"macOS","version":null,"id":null,"libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null} | 2026-02-21T04:32:52.559057 | tappi-0.9.0-py3-none-any.whl | 138,221 | 25/ca/28a69b5962414ac329add3702fd47780024ee8954e5b3e79941fc5b35079/tappi-0.9.0-py3-none-any.whl | py3 | bdist_wheel | null | false | 91263509eb6a86030378865ebdaaddb4 | b7ea919c81c193f43e52b7ecee001f17904e953e61cdceb0e24e0146b96eb75a | 25ca28a69b5962414ac329add3702fd47780024ee8954e5b3e79941fc5b35079 | MIT | [
"LICENSE"
] | 243 |
2.4 | damiao-motor | 1.0.6 | Python driver for DaMiao motors | # DaMiao Motor Python Driver
[](https://pypi.org/project/damiao-motor/)
[](https://jia-xie.github.io/python-damiao-driver/dev/)
[](https://github.com/jia-xie/python-damiao-driver)
Python driver for **DaMiao** brushless motors over CAN with a unified CLI, web GUI, and library API.
## Quick links
| Resource | Link |
|---------|------|
| Documentation home | [GitHub Pages docs](https://jia-xie.github.io/python-damiao-driver/dev/) |
| Control modes and control laws | [Motor Control Modes](https://jia-xie.github.io/python-damiao-driver/dev/concept/motor-control-modes/) |
| API reference | [DaMiaoController API](https://jia-xie.github.io/python-damiao-driver/dev/api/controller/) |
| Firmware reference | [DaMiao motor firmware (Gitee)](https://gitee.com/kit-miao/motor-firmware) |
| Source code | [GitHub repository](https://github.com/jia-xie/python-damiao-driver) |
## Highlights
- Control modes: `MIT`, `POS_VEL`, `VEL`, `FORCE_POS`
- Typical motor types: `3507`, `4310`, `4340`, `6006`, `8006`, `8009`, `10010/L`
- Unified CLI: `damiao scan`, `send-cmd-*`, register tools, and `damiao gui`
- Python API for multi-motor control with continuous feedback polling
## Installation
```bash
pip install damiao-motor
```
Requirements: Linux + CAN interface (`socketcan` on `can0`, etc.). Set CAN bitrate to match your motor before running commands.
## Quick start
Safety: these examples can move hardware. Secure the motor and keep clear of moving parts.
```bash
python examples/example.py
```
Edit `examples/example.py` to set `motor_id`, `feedback_id`, `motor_type`, and `channel`.
```python
from damiao_motor import DaMiaoController
controller = DaMiaoController(channel="can0", bustype="socketcan")
motor = controller.add_motor(motor_id=0x01, feedback_id=0x00, motor_type="4340")
controller.enable_all()
motor.ensure_control_mode("MIT")
motor.send_cmd_mit(
target_position=1.0,
target_velocity=0.0,
stiffness=20.0,
damping=0.5,
feedforward_torque=0.0,
)
state = motor.get_states()
print(state["pos"], state["vel"], state["torq"])
controller.shutdown()
```
## Control laws
### MIT mode (impedance control)
```text
T_ref = Kp * (p_des - theta_m) + Kd * (v_des - dtheta_m) + tau_ff
iq_ref = T_ref / K_T
id_ref = 0
```
Full mode documentation:
- [MIT / POS_VEL / VEL / FORCE_POS overview](https://jia-xie.github.io/python-damiao-driver/dev/concept/motor-control-modes/)
## CLI commands
All `damiao` subcommands require `--motor-type` (example: `4340`).
| Command | Purpose |
|---------|---------|
| `damiao scan --motor-type 4340` | Scan bus for motors |
| `damiao send-cmd-mit --motor-type 4340 --id 1` | MIT command |
| `damiao send-cmd-pos-vel --motor-type 4340 --id 1` | POS_VEL command |
| `damiao send-cmd-vel --motor-type 4340 --id 1` | VEL command |
| `damiao send-cmd-force-pos --motor-type 4340 --id 1` | FORCE_POS command |
| `damiao set-zero-command --motor-type 4340 --id 1` | Zero hold command |
| `damiao set-zero-position --motor-type 4340 --id 1` | Set current position to zero |
| `damiao set-can-timeout --motor-type 4340 --id 1 --timeout-ms 1000` | Set CAN timeout (reg 9) |
| `damiao set-motor-id` / `damiao set-feedback-id` | Change IDs (reg 8 / reg 7) |
| `damiao gui` | Launch web GUI |
## Web GUI
```bash
damiao gui
```
Open the local web UI (default to http://127.0.0.1:5000).
GUI docs: [Web GUI guide](https://jia-xie.github.io/python-damiao-driver/dev/package-usage/web-gui/)
## API reference
- [`DaMiaoController(channel, bustype)`](https://jia-xie.github.io/python-damiao-driver/dev/api/controller/#damiao_motor.core.controller.DaMiaoController)
- [`controller.add_motor(motor_id, feedback_id, motor_type)`](https://jia-xie.github.io/python-damiao-driver/dev/api/controller/#damiao_motor.core.controller.DaMiaoController.add_motor)
- [`motor.ensure_control_mode(mode)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.ensure_control_mode)
- [`motor.send_cmd_mit(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.send_cmd_mit)
- [`motor.send_cmd_pos_vel(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.send_cmd_pos_vel)
- [`motor.send_cmd_vel(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.send_cmd_vel)
- [`motor.send_cmd_force_pos(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.send_cmd_force_pos)
- [`motor.send_cmd(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.send_cmd)
- [`motor.get_states()`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.get_states)
- [`motor.get_register(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.get_register) / [`motor.write_register(...)`](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/#damiao_motor.core.motor.DaMiaoMotor.write_register)
API docs:
- [Controller API](https://jia-xie.github.io/python-damiao-driver/dev/api/controller/)
- [Motor API](https://jia-xie.github.io/python-damiao-driver/dev/api/motor/)
| text/markdown | null | jia <jiaxiejason@gmail.com> | null | null | MIT | damiao, motor, can, robotics | [] | [] | null | null | >=3.8 | [] | [] | [] | [
"python-can<5.0,>=4.3",
"flask<4.0,>=3.0",
"mkdocs>=1.5.0; extra == \"docs\"",
"mkdocs-material>=9.0.0; extra == \"docs\"",
"mkdocstrings[python]>=0.24.0; extra == \"docs\"",
"ruff>=0.15.1; extra == \"docs\""
] | [] | [] | [] | [
"Homepage, https://github.com/jia-xie/python-damiao-driver",
"Repository, https://github.com/jia-xie/python-damiao-driver"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-21T04:32:25.995524 | damiao_motor-1.0.6.tar.gz | 1,113,210 | 87/29/6da7d209e7d892f98a517b03286efff8d168a0b9b37878e0d809bb82dfd1/damiao_motor-1.0.6.tar.gz | source | sdist | null | false | 39b29dbb8ed74bf7144eab27fd6b0f20 | c9ce7290a310b1a96120447d5c16242c6dec44e9b02f10de964c900d7db96e14 | 87296da7d209e7d892f98a517b03286efff8d168a0b9b37878e0d809bb82dfd1 | null | [] | 245 |
2.4 | KNF | 1.0.3 | Automated Descriptor Engine for SNCI, SCDI, and 9D KNF | # KNF-CORE (KNF-GPU Branch)
KNF-CORE is an automated computational chemistry pipeline that generates:
- SNCI
- SCDI variance
- 9D KNF vector (`f1` to `f9`)
from molecular structure files using xTB + NCI backend + KNF post-processing.
Current package version in this branch: `1.0.3`
## Branch Highlights
This `KNF-GPU` branch includes:
- Torch-based NCI backend (`--nci-backend torch`) with CPU/CUDA execution.
- Multiwfn backend still supported (`--nci-backend multiwfn`).
- GPU overlap scheduler in batch mode (CPU pre-NCI + single GPU post-NCI lane) when using `torch + cuda`.
- Storage-efficient default output behavior (intermediates removed by default, keep with `--full-files`).
- Robust filename/path artifact handling for mojibake/Unicode path variants.
- xTB optimization capped to 50 cycles (`--cycles 50`) and pipeline continues if `xtbopt.xyz` exists.
- Batch aggregate outputs: `batch_knf.json` and `batch_knf.csv`.
## Fragment Handling
- `1` fragment: `f1 = 0.0`, `f2 = 180.0`
- `2` fragments: `f1` = COM distance, `f2` = detected H-bond angle
- `>2` fragments: `f1` = average COM distance over unique pairs, `f2 = 180.0`
## Requirements
- Python `>=3.8`
- External tools in `PATH`:
- `xtb`
- `obabel` (Open Babel)
- `Multiwfn` is required only when using `--nci-backend multiwfn`
Optional:
- `torch` (for Torch NCI backend; CUDA optional)
## Install
From source:
```bash
git clone https://github.com/Prasanna163/KNF.git
cd KNF
pip install -e .
```
Install with Torch extra:
```bash
pip install -e ".[torch-nci]"
```
From PyPI:
```bash
pip install KNF
```
## First-Run Setup
On first execution, KNF runs one-time setup that:
- checks external dependencies
- attempts automatic install for some tools (when available)
- computes multiprocessing recommendation
State file:
- `~/.knf/first_run_state.json`
Force refresh:
```bash
knf <input_path> --refresh-first-run
```
## Multiwfn Detection and Path Registration
Search order:
- current `PATH`
- `KNF_MULTIWFN_PATH` env var
- saved path `~/.knf/tool_paths.json`
- common local locations + shallow scan
Manual registration:
```bash
knf <input_path> --multiwfn-path "E:\path\to\Multiwfn.exe"
```
You can also pass a folder containing `Multiwfn.exe`.
## CLI Usage
Basic:
```bash
knf input_molecule.sdf
```
### Core options
- `--charge <int>`
- `--spin <int>`
- `--force`
- `--clean`
- `--debug`
- `--processing <auto|single|multi>`
- `--multi` / `--single` (shortcuts)
- `--workers <int>`
- `--output-dir <path>`
- `--ram-per-job <MB>`
- `--refresh-autoconfig`
- `--quiet-config`
- `--full-files`
- `--refresh-first-run`
- `--multiwfn-path <path>`
### Backend options
- `--gpu` shortcut: sets `torch + cuda + float64`
- `--multiwfn` shortcut: sets `multiwfn + auto`
- `--nci-backend <torch|multiwfn>`
### Advanced NCI options (hidden in default `--help`, but supported)
- `--nci-grid-spacing <float>`
- `--nci-grid-padding <float>`
- `--nci-device <cpu|cuda|auto>`
- `--nci-dtype <float32|float64>`
- `--nci-batch-size <int>`
- `--nci-eig-batch-size <int>`
- `--nci-rho-floor <float>`
- `--nci-apply-primitive-norm`
### Examples
```bash
knf example.mol --force
knf ./molecules --processing multi --workers 4 --ram-per-job 200
knf example.mol --nci-backend torch --nci-device cuda --nci-dtype float64
knf example.mol --gpu
knf example.mol --multiwfn
```
## Torch NCI Backend Notes
- Uses internal Molden parser + grid + RDG pipeline.
- Supports Cartesian shells for basis expansion.
- Spherical `d/f/g` shell Molden inputs are currently not supported.
- SNCI/statistics can be computed from either text grid (`.txt`) or compressed grid (`.npz`).
## Output Layout
Default output root:
- file input: `<input_parent>/Results/<input_stem>/`
- directory input: `<input_dir>/Results/<file_stem>/`
Final outputs:
- `knf.json`
- `output.txt`
Batch root outputs:
- `batch_knf.json`
- `batch_knf.csv`
When `--full-files` is used, intermediate artifacts are retained (for example NCI grid artifacts and xTB/Multiwfn intermediates). Without it, storage-efficient cleanup runs automatically.
## Compare Script
Use `scripts/compare_nci.py` to compare Multiwfn and Torch NCI outputs/correlation and timing behavior.
## Docker
Build:
```bash
docker build -t knf-core:latest .
```
Run:
```bash
docker run --rm -v "$(pwd):/work" -w /work knf-core:latest example.mol --charge 0 --force
```
Compose:
```bash
docker compose up --build
```
See `README.DOCKER.md` for full details.
## Releasing
Release steps are documented in `RELEASE.md`.
## License
MIT (`LICENSE`)
| text/markdown | Prasanna Kulkarni | null | null | null | MIT | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent"
] | [] | https://github.com/Prasanna163/KNF | null | >=3.8 | [] | [] | [] | [
"numpy",
"scipy",
"rich",
"psutil",
"torch; extra == \"torch-nci\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-21T04:30:57.994079 | knf-1.0.3.tar.gz | 40,857 | 04/51/85e9adddcab522b027b0ef8c4ee631e7f13ac82a9234c3d2eb66b48f1ffb/knf-1.0.3.tar.gz | source | sdist | null | false | 8211003c633724c6f87671a0491f0ac8 | cf99885893323f5721e900e3fe9229b517e2ae57baca47d6111d9ab105fee18f | 045185e9adddcab522b027b0ef8c4ee631e7f13ac82a9234c3d2eb66b48f1ffb | null | [
"LICENSE"
] | 0 |
2.4 | roboto | 0.36.0 | Official Python toolkit for roboto.ai | # Roboto SDK
[Roboto](https://www.roboto.ai/) makes it easy to manage and analyze robotics data at scale 🤖
This package contains the official toolkit for interacting with Roboto. It consists of the `roboto` Python module and command line utility.
If this is your first time using Roboto, we recommend reading the [docs](https://docs.roboto.ai/) and exploring the [core concepts](https://docs.roboto.ai/learn/concepts.html).
<img src="https://github.com/user-attachments/assets/5f9a87e5-9012-4ec4-9a67-abf5ef733f5b" width="700"/>
## Why Roboto?
Most robotics teams start with manual review: visualizing logs and replaying data. But that approach alone doesn’t scale. It makes it hard to catch issues or measure performance as your fleet grows. Roboto helps you move beyond that. It gives you the tools to automate analysis and scale up 🚀
You can ingest logs and efficiently extract data from them — but that’s just the beginning. Roboto lets you query data and define custom actions to post-process it, so you can identify events, generate KPIs, and more.
See below for supported data formats, installation instructions and getting started [examples](#getting-started).
## Data Formats
Roboto can ingest data from a variety of formats, each with corresponding actions in the [Action Hub](https://app.roboto.ai/actions/hub).
| Format | Extensions | Status | Action |
| ----------------- | ----------------- | ------ | ----------------------- |
| **ROS 2** | `.mcap`, `.db3` | ✅ | `ros_ingestion` |
| **ROS 1** | `.bag` | ✅ | `ros_ingestion` |
| **PX4** | `.ulg` | ✅ | `ulog_ingestion` |
| **Parquet** | `.parquet` | ✅ | `parquet_ingestion` |
| **CSV** | `.csv` | ✅ | `csv_ingestion` |
| **Journal** | `.log` | ✅ | `journal_log_ingestion` |
Roboto’s extensible design can also support custom formats. **[Reach out](https://www.roboto.ai/contact)** to discuss your use case.
## Install Roboto
To use the Roboto SDK and CLI:
- Sign up at [app.roboto.ai](https://app.roboto.ai) and create an access token ([docs](https://docs.roboto.ai/getting-started/programmatic-access.html))
- Save your access token to `~/.roboto/config.json`
### Python
If you want to interact with Roboto in a Python environment, such as a Jupyter notebook, we recommend installing the Python SDK released via [PyPI](https://pypi.org/project/roboto/):
```bash
pip install roboto
```
This will also install the CLI mentioned below. See the complete [SDK](https://docs.roboto.ai/reference/python-sdk.html) and [CLI](https://docs.roboto.ai/reference/cli.html) documentation.
### CLI
If you want to interact with Roboto on the command line, and don't need the Python SDK, we recommend installing the standalone CLI.
You can find all versions of pre-built binary artifacts on the [releases](https://github.com/roboto-ai/roboto-python-sdk/releases) page of this package. We currently build for Linux (`aarch64`, `x86_64`), Mac OS X (`aarch64, x86_64`) and Windows (`x86_64`). See installation instructions per platform below.
Installing the CLI will provide the `roboto` command line utility. You can see available commands with `roboto -h` or see the complete [CLI reference](https://docs.roboto.ai/reference/cli.html) documentation.
#### Linux
- Go to the [latest release](https://github.com/roboto-ai/roboto-python-sdk/releases/latest) page for this package
- (apt) Download the relevant `roboto` `.deb` file for your platform
- e.g. `roboto-linux-x86_64_0.9.2.deb` *(don't pick a `roboto-agent` release)*
- Double click on the downloaded `deb` file and let `apt` take over
- (non-apt) Download the relevant `roboto` file for your platform
- e.g. `roboto-linux-x86_64` *(don't pick a `roboto-agent` release)*
- Move the downloaded file to `/usr/local/bin` or where ever makes sense for your platform
Coming soon: direct `apt-get install` support
#### Mac OS X
You can either use the [Homebrew](https://brew.sh/) package manager:
```bash
brew install roboto-ai/tap/roboto
```
Or download the relevant Mac binary from the [latest release](https://github.com/roboto-ai/roboto-python-sdk/releases/latest) page e.g. `roboto-macos-aarch64`
If you used Homebrew, you can also upgrade via `brew upgrade roboto`
#### Windows
- Go to the [latest release](https://github.com/roboto-ai/roboto-python-sdk/releases/latest) page for this package
- Download the `roboto-windows-x86_64.exe` file
- Move the downloaded `.exe` to a folder that is on your `PATH`, like `C:\Program Files\`
#### Upgrade CLI
The CLI will automatically check for updates and notify you when a new version is available.
If you installed the CLI with the SDK via `pip`, you can simply upgrade with `pip install --upgrade roboto`.
If you installed the CLI from a `.deb` or by adding an executable like `roboto-linux-x86_64` to your `PATH`, you can
upgrade by downloading the latest version and replacing the old executable.
For OS X Homebrew users, you can upgrade by running `brew upgrade roboto`.
### Getting Started
The CLI is convenient for quickly creating new datasets, uploading or downloading files, and running actions. The Python SDK has comprehensive support for all Roboto platform features and is great for data analysis and integration with your other tools.
#### CLI Example
With the Python SDK, or standalone CLI installed, you can use `roboto` on the command line.
The example below shows how to create a new dataset and upload a file to it.
```bash
> roboto datasets create --tag boston
{
"administrator": "Roboto",
"created": "2024-09-25T22:22:48.271387Z",
"created_by": "benji@roboto.ai",
"dataset_id": "ds_9ggdi910gntp",
...
"tags": [
"boston"
]
}
> roboto datasets upload-files -d ds_9ggdi910gntp -p scene57.bag
100.0%|█████████████████████████ | 58.9M/58.9M | 2.62MB/s | 00:23 | Src: 1 file
```
#### Python Example
With the Python SDK installed, you can import `roboto` into your Python runtime.
The example below shows how to access topic data for an ingested ROS bag file:
```python
from roboto import Dataset
ds = Dataset.from_id("ds_9ggdi910gntp")
bag = ds.get_file_by_path("scene57.bag")
steering_topic = bag.get_topic("/vehicle_monitor/steering")
steering_data = steering_topic.get_data(
start_time="1714513576", # "<sec>.<nsec>" since epoch
end_time="1714513590",
)
```
You can also create events:
```python
from roboto import Event
Event.create(
start_time="1714513580", # "<sec>.<nsec>" since epoch
end_time="1714513590",
name="Fast Turn",
topic_ids=[steering_topic.topic_id]
)
```
Or even search for logs matching metadata and statistics with [RoboQL](https://docs.roboto.ai/roboql/overview.html):
```python
from roboto import query, RobotoSearch
roboto_search = RobotoSearch(query.client.QueryClient())
query = '''
dataset.tags CONTAINS 'boston' AND
topics[0].msgpaths[/vehicle_monitor/vehicle_speed.data].max > 20
'''
results = roboto_search.find_files(query)
```
See the [notebooks](https://github.com/roboto-ai/roboto-python-sdk/tree/main/examples) directory for complete examples!
## Learn More
For more information, check out:
* [General Docs](https://docs.roboto.ai/)
* [User Guides](https://docs.roboto.ai/user-guides/index.html)
* [Example Notebooks](https://github.com/roboto-ai/roboto-python-sdk/tree/main/examples)
* [SDK Reference](https://docs.roboto.ai/reference/python-sdk.html)
* [CLI Reference](https://docs.roboto.ai/reference/cli.html)
* [About Roboto](https://www.roboto.ai/about)
## Contact
If you'd like to get in touch with us, feel free to email us at info@roboto.ai, or join our community [Discord server](https://discord.gg/r8RXceqnqH).
| text/markdown | null | null | null | Roboto AI <info@roboto.ai> | Mozilla Public License Version 2.0
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
(a) that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
(b) that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
(a) any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
(b) any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
(b) under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
(a) for any code that a Contributor has removed from Covered Software;
or
(b) for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
(c) under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
(a) such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
(b) You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
************************************************************************
* *
* 6. Disclaimer of Warranty *
* ------------------------- *
* *
* Covered Software is provided under this License on an "as is" *
* basis, without warranty of any kind, either expressed, implied, or *
* statutory, including, without limitation, warranties that the *
* Covered Software is free of defects, merchantable, fit for a *
* particular purpose or non-infringing. The entire risk as to the *
* quality and performance of the Covered Software is with You. *
* Should any Covered Software prove defective in any respect, You *
* (not any Contributor) assume the cost of any necessary servicing, *
* repair, or correction. This disclaimer of warranty constitutes an *
* essential part of this License. No use of any Covered Software is *
* authorized under this License except under this disclaimer. *
* *
************************************************************************
************************************************************************
* *
* 7. Limitation of Liability *
* -------------------------- *
* *
* Under no circumstances and under no legal theory, whether tort *
* (including negligence), contract, or otherwise, shall any *
* Contributor, or anyone who distributes Covered Software as *
* permitted above, be liable to You for any direct, indirect, *
* special, incidental, or consequential damages of any character *
* including, without limitation, damages for lost profits, loss of *
* goodwill, work stoppage, computer failure or malfunction, or any *
* and all other commercial damages or losses, even if such party *
* shall have been informed of the possibility of such damages. This *
* limitation of liability shall not apply to liability for death or *
* personal injury resulting from such party's negligence to the *
* extent applicable law prohibits such limitation. Some *
* jurisdictions do not allow the exclusion or limitation of *
* incidental or consequential damages, so this exclusion and *
* limitation may not apply to You. *
* *
************************************************************************
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to look
for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
This Source Code Form is "Incompatible With Secondary Licenses", as
defined by the Mozilla Public License, v. 2.0.
| null | [] | [] | null | null | <4,>=3.9 | [] | [] | [] | [
"boto3>=1.26",
"botocore>=1.29",
"cookiecutter>=2.5.0",
"cron-converter>=1.2.1",
"exceptiongroup>=1.0; python_version < \"3.11\"",
"filelock~=3.15",
"mcap>=1.3.0",
"mcap-ros1-support>=0.7.1",
"mcap-ros2-support>=0.5.3",
"packaging>=24.0",
"pathspec>=0.11",
"platformdirs>=4.0",
"pydantic>=2.5",
"pydantic-core>=2.14",
"pydantic-settings>=2.1",
"rich>=14.2",
"tenacity>=8.2",
"tqdm>=4.65",
"typing-extensions>=4.8; python_version < \"3.10\"",
"fsspec[http]>=2025.5.1; extra == \"analytics\"",
"numpy>=1.19; extra == \"analytics\"",
"pandas>=2.0; extra == \"analytics\"",
"pyarrow>=20.0.0; extra == \"analytics\"",
"stumpy>=1.13; extra == \"analytics\"",
"pandas>=2.0; extra == \"ingestion\"",
"pyarrow>=20.0.0; extra == \"ingestion\"",
"ipython~=8.28; extra == \"examples\"",
"jupyter~=1.1; extra == \"examples\"",
"matplotlib~=3.9; extra == \"examples\"",
"pillow~=10.4; extra == \"examples\""
] | [] | [] | [] | [
"Documentation, https://docs.roboto.ai",
"Homepage, https://www.roboto.ai",
"Issues, https://github.com/roboto-ai/roboto-python-sdk/issues",
"Repository, https://github.com/roboto-ai/roboto-python-sdk.git"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:30:51.321108 | roboto-0.36.0.tar.gz | 310,587 | 88/44/f9bda3e6533e5d2de7048ec06b5c05ec669f9cd66c54f200c03199a0b823/roboto-0.36.0.tar.gz | source | sdist | null | false | 72e21ee19d4d75dbc2786e87d9358a52 | fee7a38433709b47182d22c54b5b0e062f78ea60d7cca2660d74badf6c274f89 | 8844f9bda3e6533e5d2de7048ec06b5c05ec669f9cd66c54f200c03199a0b823 | null | [
"LICENSE"
] | 259 |
2.4 | clawagents | 3.1.0 | Python port of the ClawAgents framework | # clawagents_py
A Python port of the ClawAgents hybrid framework.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"fastapi>=0.100.0",
"google-genai>=0.1.0",
"openai>=1.0.0",
"pydantic>=2.0.0",
"python-dotenv>=1.0.0",
"uvicorn>=0.20.0",
"pytest-asyncio>=0.21; extra == \"dev\"",
"pytest>=7.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.1 | 2026-02-21T04:30:16.416566 | clawagents-3.1.0.tar.gz | 25,279 | 31/b2/b54f4da21879f3212850a902bdbcbb1801c798f1178ba6c17719a75972e7/clawagents-3.1.0.tar.gz | source | sdist | null | false | 8bec59e23f5f4214b6ed8db42f5f9607 | 796c0bb91f11a15a96b67caa7df5a2f302e74f7a45b3b4efaee94278c9256e42 | 31b2b54f4da21879f3212850a902bdbcbb1801c798f1178ba6c17719a75972e7 | null | [] | 261 |
2.4 | cl-sdk | 0.29.0 | Simulator for the Cortical Labs cl API | # CL SDK
This package provides an implementation of the CL API to assist with local development of applications that can run on a Cortical Labs CL1 system.
Please refer to [docs.corticallabs.com](https://docs.corticallabs.com) for the latest documentation.
## Prerequisites
This SDK requires Python 3.12 or later.
## Installation
Use of a venv is recommended:
```bash
$ python3 -m venv .venv
$ source .venv/bin/activate
$ pip3 install cl-sdk
```
## Cortical Labs Developer Guide
This SDK is capable of running most of the Jupyter notebooks in our developer guide. Install cl-sdk as above, then:
```bash
$ git clone https://github.com/Cortical-Labs/cl-api-doc.git
```
From here you can open and run the `*.ipynb` notebooks directly in Visual Studio Code, or by installing and running Jupyter Lab:
```bash
$ pip3 install jupyterlab
$ jupyter lab cl-api-doc
```
### Development
For working on the simulator itself:
```bash
$ pip3 install -e .
```
### Running Tests
```bash
$ pip3 install -e '.[test]'
$ pytest
```
### Building Documentation
```bash
$ pip3 install -e '.[test]'
$ python3 -m docs.make
```
Serve the built docs to view in a browser:
```bash
$ python3 -m http.server -d docs/html
```
## User Options
Several user options can be set by defining environment variables in a `.env` file of your project directory.
### Simulation from a recording
Spikes and samples are simulated by replaying recordings as set by the `CL_SDK_REPLAY_PATH` environment variable in the `.env` file. If this is omitted, a temporary recording with randomly generated samples and spikes will be used that is based on a Poisson distribution and the following optional environment variables:
- `CL_SDK_SAMPLE_MEAN`: Mean samples value (default 170). This value will be in microvolts when multiplied by the constant "uV_per_sample_unit" in the recording attributes;
- `CL_SDK_SPIKE_PERCENTILE`: Percentile threshold for sample values, above which will correspond to a spike (default 99.995);
- `CL_SDK_DURATION_SEC`: Duration of the temporary recording (default 60); and
- `CL_SDK_RANDOM_SEED`: Random seed (defaults to Unix time).
The starting position of the replay recording will be randomised every time `cl.open()` is called. This can be overriden by setting `CL_SDK_REPLAY_START_OFFSET`, where a value of `0` indicates the first frame of the recording.
### Speed of simulation
The simulator can operate in two timing modes:
- Based on wall clock time (default), or
- Accelerated time.
Accelerated time mode can be enabled by setting `CL_SDK_ACCELERATED_TIME=1` environment variable in the `.env` file. When enabled, passage of time will be decouple from the system wall clock time, enabling accelerated testing of applications.
### WebSocket server
An included webSocket server can be used to stream simulated data. By default, the server is disabled. It can be enabled by setting `CL_SDK_WEBSOCKET=1` environment variable in the `.env` file. The port used by the server can be set using the `CL_SDK_WEBSOCKET_PORT` environment variable (default 1025). The server will be hosted on `localhost` by default, but this can be changed by setting the `CL_SDK_WEBSOCKET_HOST` environment variable. | text/markdown | null | Cortical Labs Pte Ltd <info@corticallabs.com> | null | null | CC BY-NC 4.0 | null | [
"License :: Other/Proprietary License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.12.0 | [] | [] | [] | [
"dotenv",
"ipykernel",
"matplotlib",
"msgpack",
"msgpack-numpy",
"networkx",
"numpy",
"pandas",
"pydantic",
"python-louvain",
"scipy",
"tables",
"websockets",
"inline-snapshot[black]; extra == \"test\"",
"pdoc; extra == \"test\"",
"pytest; extra == \"test\"",
"pytest-mock; extra == \"test\""
] | [] | [] | [] | [
"Homepage, https://github.com/Cortical-Labs/cl-sdk",
"Documentation, https://docs.corticallabs.com",
"Source, https://github.com/Cortical-Labs/cl-sdk"
] | twine/6.2.0 CPython/3.12.12 | 2026-02-21T04:29:41.701127 | cl_sdk-0.29.0.tar.gz | 418,508 | 1c/71/df572cbcc59baa7847af795201d88558a95503075963f65715294d40f83d/cl_sdk-0.29.0.tar.gz | source | sdist | null | false | bdffb5ad713a6dbe75258b86d84ecb74 | 1acbe6bb0e84c69c816a31bb78743994e8fb876e206a4b495a4114c9fc9268e3 | 1c71df572cbcc59baa7847af795201d88558a95503075963f65715294d40f83d | null | [
"LICENSE"
] | 253 |
2.3 | packmodsdown | 1.0.0 | Batch download mods from CurseForge modpack zip files | # PackModsDown
Batch download mods from CurseForge modpack zip files.
## Install
```bash
pip install packmodsdown
```
## Usage
```bash
pmd -m <modpack.zip> -o <output_dir> -k <api_key>
```
Or use the full name:
```bash
packmodsdown -m <modpack.zip> -o <output_dir> -k <api_key> [-c <concurrency>]
```
## Options
| Flag | Description | Default |
| ------------------- | ------------------------ | -------- |
| `-m, --modpack` | Path to modpack `.zip` | required |
| `-o, --output` | Output directory | `./mods` |
| `-k, --api-key` | CurseForge API key | required |
| `-c, --concurrency` | Max concurrent downloads | `10` |
| text/markdown | QianFuv | QianFuv <qianfuv@qq.com> | null | null | Copyright <2025> <QianFuv>
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. | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"httpx>=0.28.1",
"rich>=13.0.0",
"mypy>=1.18.2; extra == \"dev\"",
"ruff>=0.14.6; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:29:22.546156 | packmodsdown-1.0.0.tar.gz | 6,763 | d1/fc/faa7d540e9bfadce131a1f086d4b3dcc8f636832c0da0a19ada23e51efa9/packmodsdown-1.0.0.tar.gz | source | sdist | null | false | 6cf3ec14ded5947e3f1fdee5c65f230e | 78d847c301db0dd2c78aa69a920e9ab3c940cf82b24af672a07c9d301513ca59 | d1fcfaa7d540e9bfadce131a1f086d4b3dcc8f636832c0da0a19ada23e51efa9 | null | [] | 254 |
2.1 | odoo-addon-crm-timesheet | 18.0.1.0.0.4 | CRM Timesheet | .. image:: https://odoo-community.org/readme-banner-image
:target: https://odoo-community.org/get-involved?utm_source=readme
:alt: Odoo Community Association
=============
CRM Timesheet
=============
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:ce17327f1c679c48ee3e0e77909a88efa1f4d21c3ad7ce5c05b25d119a08ef36
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Ftimesheet-lightgray.png?logo=github
:target: https://github.com/OCA/timesheet/tree/18.0/crm_timesheet
:alt: OCA/timesheet
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/timesheet-18-0/timesheet-18-0-crm_timesheet
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/timesheet&target_branch=18.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
This module allows to generate timesheets from leads/opportunities.
**Table of contents**
.. contents::
:local:
Usage
=====
- In pipeline/lead forms you have Timesheet tab.
Known issues / Roadmap
======================
- Window actions crm.crm_lead_all_leads and
crm.crm_lead_opportunities_tree_view contexts are overwritten for
hiding the lead field in timesheet embedded view. As this is not
accumulative, this change might be lost by other module overwritting
the same action, or this masks another module overwritting.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/timesheet/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/timesheet/issues/new?body=module:%20crm_timesheet%0Aversion:%2018.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- Antonio Espinosa
- Rafael Blasco
- Javier Iniesta
- David Vidal
- Vicent Cubells
- Jairo Llopis
- Carolina Fernandez
- Víctor Martínez
- Foram Shah <foram.shah@initos.com>
- `Sygel <https://www.sygel.es>`__
- Harald Panten
- Valentin Vinagre
- Roger Sans
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/timesheet <https://github.com/OCA/timesheet/tree/18.0/crm_timesheet>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 18.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/timesheet | null | >=3.10 | [] | [] | [] | [
"odoo-addon-project_timesheet_time_control==18.0.*",
"odoo==18.0.*"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:26:34.722277 | odoo_addon_crm_timesheet-18.0.1.0.0.4-py3-none-any.whl | 37,308 | 68/32/768931a512cc106c83bde713a9e6e6d435c23a8206a5f1cf8ef02e665edc/odoo_addon_crm_timesheet-18.0.1.0.0.4-py3-none-any.whl | py3 | bdist_wheel | null | false | 4e78d3bde2b1424f4db5cf53b010646e | 1e3ce595c94eff990cda753145d5b16dfef725f551d7ab863c5dffe251e0e90a | 6832768931a512cc106c83bde713a9e6e6d435c23a8206a5f1cf8ef02e665edc | null | [] | 77 |
2.4 | digifact | 0.1.1 | Digifact - Manufacturing KPIs Calculation Package (OEE, MTTR, MTBF, Availability, Performance, Quality) | # Digifact
A Python package for calculating manufacturing KPIs including OEE (Overall Equipment Efficiency), Availability, Performance, Quality, MTTR, and MTBF.
## Installation
```bash
pip install digifact
| text/markdown | null | Precise <digiapp@preciseindsol.com> | null | null | MIT | manufacturing, OEE, KPI, production, MTTR, MTBF, availability, performance, quality | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Intended Audience :: Manufacturing",
"Topic :: Scientific/Engineering :: Information Analysis"
] | [] | null | null | >=3.8 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://pypi.org/project/digifact",
"Documentation, https://pypi.org/project/digifact",
"Source, https://github.com/yourusername/digifact"
] | twine/6.2.0 CPython/3.12.2 | 2026-02-21T04:26:28.774177 | digifact-0.1.1.tar.gz | 6,285 | e3/49/9dc7c3b4597842a0dee5fc63cde655efaa50729cb3cfbc9bf5ba8e38aa4e/digifact-0.1.1.tar.gz | source | sdist | null | false | de33dff79dd5e2ccbbf9a492e280fd0b | c5c99edb171f070b5def3f2e45fd328662e87a0b64c45cc81f2a3acde650415e | e3499dc7c3b4597842a0dee5fc63cde655efaa50729cb3cfbc9bf5ba8e38aa4e | null | [
"LICENSE"
] | 252 |
2.4 | mcp-tap | 0.5.3 | The last MCP server you install by hand. Discover, install, and configure MCP servers from inside your AI assistant. | # mcp-tap
**The last MCP server you install by hand.**
mcp-tap lives inside your AI assistant. Ask it to find, install, and configure
any MCP server — by talking to it. No more editing JSON files. No more
Googling environment variables. No more "why won't this connect?"
> "Find me an MCP for PostgreSQL."
That's it. mcp-tap searches the registry, installs the package, generates the
config, validates the connection — all through conversation.
## Before mcp-tap
1. Google "MCP server for postgres"
2. Find 4 competing packages, compare stars and last commit dates
3. Pick one, read the README
4. Figure out the right `command`, `args`, and `env` values
5. Manually edit `claude_desktop_config.json` (or `mcp.json`, or `mcp_config.json`...)
6. Realize you need a `POSTGRES_CONNECTION_STRING` environment variable
7. Find your connection string, add it to the config, restart the client
8. Get "connection refused", debug for 20 minutes
9. Finally works. Repeat for every server. Repeat for every client.
## After mcp-tap
```
You: "Set up MCP servers for my project."
mcp-tap: I scanned your project and found:
- PostgreSQL (from docker-compose.yml)
- Slack (SLACK_BOT_TOKEN in your .env)
- GitHub (detected .github/ directory)
I recommend 3 servers. Want me to install them?
You: "Yes, all of them."
mcp-tap: Done. All connections verified. 35 new tools available.
```
## Install
You install mcp-tap once. It installs everything else.
### Claude Desktop
Add to your `claude_desktop_config.json`:
<!-- tabs: uvx (recommended), npx -->
**With uvx** (recommended):
```json
{
"mcpServers": {
"mcp-tap": {
"command": "uvx",
"args": ["mcp-tap"]
}
}
}
```
**With npx**:
```json
{
"mcpServers": {
"mcp-tap": {
"command": "npx",
"args": ["-y", "mcp-tap"]
}
}
}
```
### Claude Code
```bash
# With uvx (recommended)
claude mcp add mcp-tap -- uvx mcp-tap
# With npx
claude mcp add mcp-tap -- npx -y mcp-tap
```
### Cursor
Add to `.cursor/mcp.json`:
```json
{
"mcpServers": {
"mcp-tap": {
"command": "uvx",
"args": ["mcp-tap"]
}
}
}
```
Or use `npx` — replace `"command": "uvx", "args": ["mcp-tap"]` with `"command": "npx", "args": ["-y", "mcp-tap"]`.
### Windsurf
Add to `~/.codeium/windsurf/mcp_config.json`:
```json
{
"mcpServers": {
"mcp-tap": {
"command": "uvx",
"args": ["mcp-tap"]
}
}
}
```
Or use `npx` — replace `"command": "uvx", "args": ["mcp-tap"]` with `"command": "npx", "args": ["-y", "mcp-tap"]`.
## What can it do?
| You say | mcp-tap does |
|---------|-------------|
| "Scan my project and recommend MCP servers" | Detects your tech stack, shows what's missing |
| "Find me an MCP for PostgreSQL" | Searches the registry, compares options |
| "Set up the official postgres server" | Installs, configures, validates the connection |
| "Set it up on all my clients" | Configures Claude Desktop, Cursor, and Windsurf at once |
| "What MCP servers do I have?" | Lists all configured servers across clients |
| "Are my MCP servers working?" | Health-checks every server concurrently |
| "Test my postgres connection" | Spawns the server, connects, lists available tools |
| "Remove the slack MCP" | Removes from config cleanly |
## Tools
| Tool | What it does |
|------|-------------|
| `scan_project` | Scans your project directory — detects languages, frameworks, databases, CI/CD pipelines — and recommends MCP servers |
| `search_servers` | Searches the MCP Registry by keyword, with maturity scoring and project relevance ranking |
| `configure_server` | Installs a package (npm/pip/docker), runs a security gate, validates the connection, and writes config |
| `test_connection` | Spawns a server process, connects via MCP protocol, and lists its tools. Auto-heals on failure |
| `check_health` | Tests all configured servers concurrently, detects tool conflicts between servers |
| `inspect_server` | Fetches a server's README and extracts configuration hints |
| `list_installed` | Shows all configured servers with secrets masked (layered detection: key names, prefixes, high-entropy) |
| `remove_server` | Removes a server from one or all client configs |
| `verify` | Compares `mcp-tap.lock` against actual config — detects drift |
| `restore` | Recreates server configs from a lockfile (like `npm ci` for MCP) |
| `apply_stack` | Installs a group of servers from a shareable stack profile |
Plus automatic lockfile management on every configure/remove.
## Features
- **Project-aware**: Scans your codebase — including CI/CD configs (GitHub Actions, GitLab CI) — to recommend servers based on your actual stack
- **Security gate**: Blocks suspicious install commands, archived repos, and known-risky patterns before installing
- **Lockfile**: `mcp-tap.lock` tracks exact versions and hashes of all your MCP servers. Reproducible setups across machines
- **Stacks**: Shareable server profiles — install a complete Data Science, Web Dev, or DevOps stack in one command
- **Multi-client**: Configure Claude Desktop, Claude Code, Cursor, and Windsurf — all at once or individually
- **Auto-healing**: Failed connections are automatically diagnosed and fixed when possible
- **Tool conflict detection**: Warns when two servers expose overlapping tools that could confuse the LLM
- **Connection validation**: Every install is verified with a real MCP connection test
- **Secrets masked**: `list_installed` never exposes environment variable values
## Requirements
- Python 3.11+ with [`uv`](https://docs.astral.sh/uv/) (recommended), **or**
- Node.js 18+ (the npm package is a thin wrapper that calls the Python package via `uvx`/`pipx`)
## License
MIT
| text/markdown | Felipe Stenzel | null | null | null | null | ai, discovery, mcp, model-context-protocol, tools | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"httpx>=0.27.0",
"mcp>=1.12.0",
"pyyaml>=6.0"
] | [] | [] | [] | [
"Homepage, https://github.com/felipestenzel/mcp-tap",
"Repository, https://github.com/felipestenzel/mcp-tap"
] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-21T04:26:24.442638 | mcp_tap-0.5.3.tar.gz | 368,510 | 6a/92/4a9b98b47524884f2d286e395df8320d419df4f41b547b43a6182db0c8d9/mcp_tap-0.5.3.tar.gz | source | sdist | null | false | 1733d057a333994336ac57c105decaf0 | f1b40e9914d8845123632c389d6f674f11d5e1df5f2abb4a7be6cc18e9018674 | 6a924a9b98b47524884f2d286e395df8320d419df4f41b547b43a6182db0c8d9 | MIT | [
"LICENSE"
] | 239 |
2.4 | smrpgpatchbuilder | 1.5.8 | Patchable base class support for some SMRPG concepts similar to their definitions in Lazy Shell | # SMRPG Patch Builder
Freeform editing of various things in Super Mario RPG.
This is not a decomp.
## How this works
Convert some contents of your ROM into Python code so you can freely edit it, then create a patch to get your changes into your ROM. You can do this for:
- ✅ [event scripts](#event-and-action-scripts)
- ✅ [battle animation scripts](#battle-animation-scripts)
- ✅ [monsters](#monsters)
- ✅ [monster AI scripts](#monster-ai-scripts)
- ✅ [monster attacks](#monster-attacks)
- ✅ [monster and ally spells](#monster-and-ally-spells)
- ✅ [allies](#allies)
- ✅ [items](#items)
- ✅ [sprites](#sprites)
- ✅ [shops](#shops)
- ✅ [overworld dialogs](#overworld-dialogs)
- ✅ [battle dialogs and battle messages](#battle-dialogs-and-messages)
- ✅ [battle packs and formations](#battle-packs-and-formations)
- ✅ [packet NPCs](#packet-npcs)
- ✅ [rooms and NPCs](#rooms-and-npcs)
- ✅ [overworld location data](#overworld-location-data)
(✅ = roundtrip tested and working. Roundtrips will not be 100% identical bytewise because monster pointers are rearranged, dialogs are optimized, etc, but they will look the same in Lazy Shell.)
You can also take the contents of your disassembler_output folder and stick it in whatever Python project you want, as long as that project imports this package. (example: SMRPG randomizer)
## Getting started
These instructions are for bash terminals (no powershell). On Windows, you can use WSL (note that your ROM will be in `/mnt/some_drive_letter/path/to/your/smrpg/rom`) but setup for WSL is beyond the scope of this guide.
### Step 0
- Install the Python runtime for your operating system. All further steps assume that your PATH variable will execute python 3 when you use `python` in the command line (and that you don't have that pointing to a separate python 2 install for example)
- Create a virtual environment: `python -m venv MyVirtualEnvironmentNameWhateverIWant`
- Activate the virtual environment: `source ~/.venvs/MyVirtualEnvironmentNameWhateverIWant/bin/activate` (might differ depending on your setup, use google if that's the case)
- Install required packages: `pip install -r requirements.txt`
Everything you do beyond this point must be in your venv. You'll know you're in your venv when your terminal prompts have your venv name in them, like this if you use vscode:
```
(MyVirtualEnvironmentNameWhateverIWant) stef@Stefs-MBP smrpgpatchbuilder %
```
### Step 1
This patch builder helps you remember the context of the things you're building. The first thing you should do is copy the contents of the config.example folder into the config folder.
Then inside the config folder, you'll see a bunch of plaintext files. They are:
- `action_script_names.input`: Describe your 1024 action scripts.
- `animationdata_write.input`: If you want to move animation pack data for sprites to anywhere else in the ROM beyond where SMRPG keeps it by default (which you could do if you want to free up space for sprite tile data in 0x280000-0x370000), indicate your desired ranges here. Be sure to break them up by upper byte so that they work correctly.
- `animationpack_read.input`: If you have moved the pointer table for sprite animation pack data to anywhere else in the ROM besides where SMRPG keeps it by default, indicate the range here.
- `battle_effect_names.input`: These are the things you edit in the `Effects` editor in Lazy Shell (128 total).
- `battle_event_names.input`: There are 103 battle events in the game, you can describe them here if you have modified them.
- `battle_sfx_names.input`: If you have changed any of the 211 sound effects accessible during battle, you can name them here.
- `battle_variable_names.input`: If you've modified monster AI scripts in a way that reserves certain $7EE00x variables for certain purposes, you can describe them here.
- `battlefield_names.input`: If you've changed any of the 64 battlefields, rename them here.
- `dialog_names.input`: If you want to remember what certain overworld dialogs are being used for, you can give them names here. There's 4096 of them, so it can be handy.
- `event_script_names.input`: Describe your 4096 event scripts.
- `imagepack_read.input`: If you have moved image pack data for sprites to anywhere else in the ROM besides where SMRPG keeps it by default, indicate the range here.
- `item_prefixes.input`: Items and ally spells can begin with a special symbol or a blank space. If you've changed what any of those symbols look like in your ROM's alphabet, indicate them here. (i.e. if you've replaced the fan symbol, normally 0x26, wholesale with some other symbol, rename it here)
- `music_names.input`: Rename the game's music tracks if you've changed them.
- `overworld_area_names`: Rename the 56 world map destinations here if you need to.
- `overworld_sfx_names`: If you have changed any of the 163 sound effects accessible in the overworld, you can name them here. (There are actually 256 rows because there is one instance in the original game of a SFX command trying to use ID 255, so ID 255 acts as a placeholder)
- `pack_names.input`: Describe any of the 256 battle pack definitions here (these are referenced by overworld scripts when loading a specific battle)
- `packet_names.input`: A packet is a NPC created on the fly by an event script or action script (as opposed to a NPC that exists in the room definition), such as the mushrooms/flowers/etc that appear temporarily when you open a treasure chest. You can disassemble and edit those. In this file, put descriptive names for them.
- `room_names.input`: You can name the 510 levels in the game. By default most of these are derived from the level descriptions in Lazy Shell.
- `screen_effect_names.input`: If you've changed any of the 21 screen effects used in battle, you can describe them here.
- `shop_names.input`: If you've changed any of the 33 shops, rename them here.
- `sprite_names.input`: Give names to the 1024 NPC sprites in your ROM.
- `tiles_read.input`: The list of ranges where uncompressed NPC tiles are in the ROM
- `tiles_write.input`: The list of ranges where uncompressed NPC tiles in the ROM should be written to (if you've moved animation packs somewhere else, for instance, you could expand this to accommodate more tiles). Be sure to break them up by upper byte so that pointers work correctly, see example file. This should be the same as tiles_read.input if you want to read and write tile data to the same place.
- `toplevelsprite_read.input`: The addresses where sprite containers live (which hold image pack data and animation pack data to make a whole sprite). This should only be one line. You can change it if you've moved that data in your ROM to somewhere else.
- `variable_names.input`: Every $7000 var and $7000 var bit that can be used by Lazy Shell's event script editor is in this file. Rename the variables according to what you're using them for in your ROM.
Make sure that even if you don't rename any variables, **do not delete any lines**, it will mess up your code that uses it.
<sup>Note: There are no files here to name your items, enemies, attacks, or spells. This is on purpose! Those will be retrieved from your ROM in a different way.</sup>
### Step 2
Run
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py variableparser
```
in the root folder of this repo. It will create files in `./src/disassembler_output/variables` that define Python variables according to the names you gave in Step 1. Everything else you disassemble will be using these.
### Step 3
Disassemble items, spells, monster attacks, and packets by running:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py itemdisassembler --rom "/path/to/your/smrpg/rom"
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py enemyattackdisassembler --rom "/path/to/your/smrpg/rom"
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py spelldisassembler --rom "/path/to/your/smrpg/rom"
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py packetdisassembler --rom "/path/to/your/smrpg/rom"
```
These will produce:
- `./src/disassembler_output/items.items.py`
- `./src/disassembler_output/enemy_attacks/attacks.py`
- `./src/disassembler_output/spells/spells.py`
- `./src/disassembler_output/packets/packets.py`
It is important to do these next because other things will use these. Event scripts and monster definitions (ie loot drops) will need to reference items, monster AI scripts use attacks and spells, allies use spells, and event/action scripts use packets.
### Step 4
Disassemble monsters:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py enemydisassembler --rom "/path/to/your/smrpg/rom"
```
These will produce `./src/disassembler_output/enemies/enemies.py`. It is important to do this now because other data types (battle animations, monster AI, battle packs) depend on this data.
### Step 5
Now you can disassemble whatever else you want. There are no more dependencies.
## Details on the things you can disassemble and patch
### Event and action scripts
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py eventconverter --rom "path/to/your/smrpg/rom" # be warned, this will probably take a few hours
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py eventassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/overworld_scripts/event
./src/disassembler_output/overworld_scripts/animation
```
For an example of an overworld script, if your ROM has this:
you would get this:
```python
# E0313_MUSHROOM_KINGDOM_OCCUPIED_GRANDMA
script = EventScript([
RunDialog(dialog_id=DI0676_GRANDMA_DURING_MK_INVASION, above_object=MEM_70A8, closable=True, sync=False, multiline=True, use_background=True),
Return()
])
```
You can then edit that however you like. For example you could set a variable:
```python
# E0313_MUSHROOM_KINGDOM_OCCUPIED_GRANDMA
script = EventScript([
RunDialog(dialog_id=DI0676_GRANDMA_DURING_MK_INVASION, above_object=MEM_70A8, closable=True, sync=False, multiline=True, use_background=True),
AddConstToVar(COIN_COUNTER_1, 1),
Return()
])
```
You can also use `Jump to address` commands without having to worry about pointer addresses at all*. In this example, `JmpIfBitClear` is looking for a name instead of a $xxxx pointer, and the `SetBit` command further below has the name it's looking for:
```python
script = EventScript([
JmpIfBitClear(UNKNOWN_7049_4, ["LabelGoesHere"]), # This will skip the RunDialog command by jumping to the SetBit command
RunDialog(
dialog_id=DI0520_LITTLE_SHORT_ON_COINS,
above_object=MEM_70A8,
closable=True,
sync=False,
multiline=True,
use_background=True,
),
SetBit(INSUFFICIENT_COINS, identifier="LabelGoesHere"),
JmpToEvent(E3072_FLOWER_STAR_FC_OR_MUSHROOM_CHEST)
])
```
This disassembler/assembler always processes event scripts and action scripts together. Action scripts look like this:
```python
#A0002_FLASH_AFTER_RUNNING_AWAY_IFRAMES
script = ActionScript([
A_ObjectMemorySetBit(arg_1=0x30, bits=[4]),
A_JmpIfBitClear(TEMP_707C_1, ["ACTION_2_start_loop_n_times_3"]),
A_ClearSolidityBits(bit_4=True, cant_walk_through=True),
A_StartLoopNTimes(15, identifier="ACTION_2_start_loop_n_times_3"),
A_Pause(2),
A_VisibilityOff(),
A_Pause(2),
A_VisibilityOn(),
A_EndLoop(),
A_SetSolidityBits(bit_4=True, cant_walk_through=True),
A_ObjectMemoryClearBit(arg_1=0x30, bits=[4]),
A_ReturnQueue()
])
```
<sup>(All action script commands are prefixed with `A_` to distinguish them from event script commands.)</sup>
Embedded action queues within event scripts are also supported. They use the same contents as action scripts:
```python
# E0255_EXP_STAR_HIT
script = EventScript([
DisableObjectTrigger(MEM_70A8),
StartSyncEmbeddedActionScript(target=MEM_70A8, prefix=0xF1, subscript=[
A_SetObjectMemoryBits(arg_1=0x0B, bits=[0, 1]),
A_Db(bytearray(b'\xfd\xf2'))
]),
SetSyncActionScript(MEM_70A8, A1022_HIT_BY_EXP_STAR),
IncEXPByPacket(),
JmpIfVarEqualsConst(PRIMARY_TEMP_7000, 0, ["EVENT_255_ret_13"]),
SetBit(UNKNOWN_MIMIC_BIT, identifier="EVENT_255_set_bit_5"),
SetBit(EXP_STAR_BIT_6),
UnfreezeAllNPCs(),
Pause(3),
CreatePacketAtObjectCoords(packet=P031_LEVELUP_TEXT, target_npc=MARIO, destinations=["EVENT_255_set_bit_5"]),
PlaySound(sound=SO095_LEVEL_UP_WITH_STAR, channel=6),
SetVarToConst(TIMER_701E, 64),
RunBackgroundEventWithPauseReturnOnExit(event_id=E0254_EXP_STAR_HIT_SUBROUTINE, timer_var=TIMER_701E),
Return(identifier="EVENT_255_ret_13")
])
```
When it comes time to build your scripts into ROM patches, the builder code will convert names into pointers for you.
<sup>*caveat: you still need to be conscious about the script ID because two-byte pointers are still a thing. Jump commands in scripts 0-1535 can only jump to other scripts in 0-1535 (0x1Exxxx), same with 1536-3071 (0x1Fxxxx), same with 3072-4095 (0x20xxxx).</sup>
The `__init__.py` in each of the two output folders will export either a `ActionScriptBank` or three `EventScriptBank`s. If you want to use these in another Python project, it should import these. For both types, `bank.render()` returns a bytearray that when building your ROM should be patched at `bank.pointer_table_start`.
Notes:
- You can Ctrl+F the name of a command in Lazy Shell in src/smrpgpatchbuilder/datatypes/overworld_scripts to find the documentation for how to use that command in Python.
- The disassembler will produce scripts that add up to exactly the amount of bytes each bank can contain. To free up space, go to the final script (event 4095, action 1023) and delete all of the trailing `EndAll` class instantiators.
- Yo'ster Isle (events 470, 1837, 1839, 3329, 3729) has some weird implementation of this called "non-embedded action queues." That's event script code that's supposed to be read as NPC animation script code, despite having no header to indicate that. Non-embedded action queues are expected to begin at a certain offset relative to the start of the event. These are the five events that editing is disabled for in Lazy Shell. With disassembled scripts, you can edit these scripts if you like, but if you add too much code such that the NEAQ is pushed to a greater offset than it's expected to be, you'll get an error when building your patch. (Removing code before the NEAQ is fine, the assembler will fill in space to adjust it.)
- There's a couple of overrides that are technically legal but that you should probably never do. Normally, when you're using commands that jump to other commands, you specify another command's `identifier` property as the destination, so that this code will take care of filling these in with ROM addresses for you. However, event 580 in the original game issues a jump to an address that isn't associated to an event. I've flagged this with `ILLEGAL_JUMP` in the identifier, which means you're allowed in general to use a destination of `ILLEGAL_JUMP_XXXX` where `XXXX` is a four-digit hex int indicating the offset you want to jump to and is unassociated with any other command. I *strongly* recommend against ever doing this.
- Similarly, queue 53 and queue 137 use sound ID 255. I have no idea what that is, but it's accommodated for. This is another thing that's technically legal but that you shouldn't do.
<sub>([back to top](#how-this-works))</sub>
### Battle animation scripts
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py animationdisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py animationassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/battle_animation/scripts.py
```
which exports three folders, each with its own `AnimationScriptBank` class (one for $02xxxx, one for $35xxxx, one for $3Axxxx) - if you want to use your disassembled scripts in another Python project, these are what your project should import. `bank.render()` return type is `list[tuple[int, bytearray]]`, when building your ROM patch, each bytearray should be patched at its corresponding int (address).
For an example of a battle animation script, if your ROM has:
you would get this:
```python
# BE0022_YARIDOVICH_MIRAGE_ATTACK
script = BattleAnimationScript(header=["command_0x3a647c"], script = [
RunSubroutine(["command_0x3a7531"]),
SpriteQueue(field_object=1, destinations=["queuestart_0x3ac3b2"], bit_2=True, bit_4=True),
RunSubroutine(["command_0x3a7729"]),
PauseScriptUntil(condition=FRAMES_ELAPSED, frames=90),
ClearAMEM8Bit(0x68),
SetAMEMToRandomByte(amem=0x68, upper_bound=7),
JmpIfAMEM8BitLessThanConst(0x68, 3, ["command_0x3a646c"]),
SpriteQueue(field_object=0, destinations=["queuestart_0x3ac345"], bit_2=True, bit_4=True),
SpriteQueue(field_object=1, destinations=["queuestart_0x3ac35f"], bit_2=True, bit_4=True),
Jmp(["command_0x3a6476"]),
SpriteQueue(field_object=1, destinations=["queuestart_0x3ac345"], bit_2=True, bit_4=True, identifier="command_0x3a646c"),
SpriteQueue(field_object=0, destinations=["queuestart_0x3ac35f"], bit_2=True, bit_4=True),
RunSubroutine(["command_0x3a771e"], identifier="command_0x3a6476"),
Jmp(["command_0x3a7550"]),
SetAMEM32ToXYZCoords(origin=ABSOLUTE_POSITION, x=183, y=127, z=0, set_x=True, set_y=True, set_z=True, identifier="command_0x3a647c"),
NewSpriteAtCoords(sprite_id=SPR0482_YARIDOVICH, sequence=0, priority=2, vram_address=0x7800, palette_row=12, overwrite_vram=True, looping=True, overwrite_palette=True, behind_all_sprites=True, overlap_all_sprites=True),
RunSubroutine(["command_0x3a756c"]),
SummonMonster(monster=Yaridovich, position=1, bit_6=True, bit_7=True)
])
```
<sup>(note you can see how your custom battle event names and sprite names are used here!)</sup>
Battle animations are typically the most restrictive type of script to edit because of how sensitive pointers to things like object queues and sprite queues are, but those restrictions are accounted for to give you more freedom. This is accomplished by the disassembler reading all of the scripts it can find in your ROM and recursively tracing through them to find subroutines, object queues, sprites queues, etc to build a profile of how much code it can find and where it lives. Like with event and action scripts, pointers (including object/sprite queue pointers) are replaced with name strings.
This allows you to freely edit your battle animation scripts however you like, just as if they were event scripts or animation scripts. For example, there's no longer any need to worry about whether a command you're trying to replace will be the same size or not. The assembler will warn you if your code is too long and will go out of bounds, and if it's not, it'll proceed to build your patch and calculate pointers on its own.*
Battle animations however are NOT like event scripts and action scripts in that script files are not separated by pointer. When the disassembler recursively traces your code, it builds a profile of which ranges within the ROM it can verify are being used, and then create one script file per contiguous range. That means in the above Yaridovich script, you can see the code that comes after what would be the final "Jump to $3A7550" command in Lazy Shell.
<sup>*caveat: you still need to be conscious about where in the ROM your script is going. Commands in 0x35xxxx can't jump to 0x02xxxx or 0x3Axxxx or vice versa.</sup>
This is still easily the most volatile part of the game that this repo lets you edit, so here are some considerations to be aware of:
- You can Ctrl+F the name of a command in Lazy Shell in src/smrpgpatchbuilder/datatypes/battle_animation_scripts to find the documentation for how to use that command in Python.
- This is still very, very much in alpha. The recursive tracer will find every branch of every object queue it can detect as used to the best of my understanding. It is probably still an imperfect approximation and not completely comprehensive.
- Every script file you get will include an address that it intends to patch to and an expected size that it shouldn't exceed. **Do not change these.** This is determined by what parts of the ROM the disassembler was able to access when reading your code. Changing this value means you might be overwriting something that wasn't hit by the recursive trace, aka something the assembler doesn't know exists and might be bad to overwrite.
- If your changed script is shorter than the script's expected size, that's okay! It just can't be longer than the expected size.
- I've done my best to make sure that pointers referenced outside of battle animations (such as monster definitions including pointers to where their sprite behaviours live) will stay intact, however it's possible that there are some I missed, which means those external pointers will no longer work if your code changes shape too much. Let me know if you come across anything like that and I can add it to the disassembler.
- Pointer tables for things like weapons, battle events, etc are treated as object queues, because that's basically what they are. For reasons above, don't try to add or remove pointers from these unless you really know what you're doing.
- If you've changed the start or end of any top-level pointer tables in your ROM, then this will not work correctly and you will need to fork this repo and modify the `banks` dict of animationdisassembler.py. (If you're doing this, note the `end` address of a bank dict entry is **inclusive**, not exclusive. Don't ask me why I did it that way because I don't remember).
- Object queues always assume that their pointers point only toward code that comes AFTER it. For example if you define an object queue at $3A1234 and the first pointer is `0x23 0x01`, it might compile correctly, but it will never decompile correctly after that. Be careful to avoid doing this.
- The "Ally tries to run" animation in the original game does something weird, as in it jumps to a byte that is actually an argument of another command and not a command on its own. The disassembler forcibly changes this so that it points instead to a real command. This required some educated guesses about what opcodes 0x02 and 0x47 do, so you'll see those command classes named with the word "EXPERIMENTAL" in them. No other scripts in the original game do this as far as I could find.
- `UnknownCommand`s produced by the disassembler are raw bytes whose opcode we don't know what it does. It's possible that some of these undocumented commands might be pointers, which means the code will break if the destination these raw bytes were meant to point to changes. If this happens, let me know and I'll see if you might have discovered an opcode that uses a pointer, and will integrate it into this code (for example I had to do this for 0x47).
<sub>([back to top](#how-this-works))</sub>
### Monsters
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py enemydisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py enemyassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/enemies/enemies.py
```
Using Mokura as an example:
The disassembler produces this Python class:
```python
class MOKURA(Enemy):
"""MOKURA enemy class"""
_monster_id: int = 148
_name: str = "MOKURA"
_hp: int = 620
_fp: int = 100
_attack: int = 120
_defense: int = 75
_magic_attack: int = 80
_magic_defense: int = 90
_speed: int = 25
_evade: int = 20
_magic_evade: int = 10
_status_immunities: List[Status] = [Status.MUTE, Status.SLEEP, Status.POISON, Status.FEAR]
_resistances: List[Element] = [Element.THUNDER, Element.JUMP]
_xp: int = 90
_coins: int = 0
_yoshi_cookie_item = MushroomItem
_rare_item_drop = RoyalSyrupItem
_common_item_drop = KerokeroColaItem
_flower_bonus_type: FlowerBonusType = FlowerBonusType.ATTACK_UP
_flower_bonus_chance: int = 20
_sound_on_hit: HitSound = HitSound.CLAW
_sound_on_approach: ApproachSound = ApproachSound.NONE
_coin_sprite: CoinSprite = CoinSprite.NONE
_entrance_style: EntranceStyle = EntranceStyle.NONE
_monster_behaviour: str = "unknown_0x350ADF"
_elevate: int = 2
_ohko_immune: bool = True
_psychopath_message: str = " Mwa ha ha...[await]"
# TODO cursor positions
```
The disassembler creates an `EnemyCollection` containing all 256 enemies:
```python
ALL_ENEMIES = EnemyCollection([
Goomba(),
Spikey(),
...
])
```
Other things like battle packs will import these classes.
If you want to use these in another Python project, you'll need to import the `EnemyCollection`. To build a patch for it, you will _also_ need an `AnimationScriptBank` (so that it can figure out what pointers to use for your monsters' sprite behaviours). `enemycollection.render(animationscriptbank.build_command_address_mapping())` produces a `dict[int, bytearray]` where each `int` is a ROM address where its corresponding `bytearray` should be patched.
NOTE: You can't change the Sprite Behaviour property in these Enemy classes. Those are completely taken care of by the battle animation assembler. When disassembling battle animations, you will see a file (usually with 0x350202 in the filename) that has an object queue of 256 pointer names. These match up to the enemy's ID and they indicate where their sprite behaviour table starts. If you want to change an entrance style then you will just have to change which pointer to use at that index.
<sub>([back to top](#how-this-works))</sub>
### Monster AI scripts
This was based off of the battle disassembler that patcdr made in smrpg randomizer that enabled spell randomization!
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py battledisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py battleassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/monster_ai/monster_scripts.py
```
which exports a `MonsterScriptBank` - if you want to use your disassembled scripts in another Python project, this is what your project should import. `bank.render()` returns `tuple[bytearray, bytearray]` - when building your ROM patch, the first `bytearray` should go to `bank.range_1_start` and the second to `bank.range_2_start`.
For individual scripts, if you have this in your ROM:
the disassembler will give you:
```python
# 204 - Megasmilax
script = MonsterScript([
IfVarBitsClear(BV7EE00A, [0]),
SetVarBits(BV7EE00A, [0]),
CastSpell(PetalBlastSpell),
Wait1TurnandRestartScript(),
IfTurnCounterEquals(4),
CastSpell(PetalBlastSpell),
ClearVar(BV7EE005_ATTACK_PHASE_COUNTER),
Wait1TurnandRestartScript(),
ClearVar(BV7EE005_DESIGNATED_RANDOM_NUM_VAR),
Set7EE005ToRandomNumber(upper_bound=7),
IfVarLessThan(BV7EE005_DESIGNATED_RANDOM_NUM_VAR, 4),
SetVarBits(BV7EE00F, [0]),
Attack(Attack0, Attack0, ScrowDustAttack),
ClearVarBits(BV7EE00F, [0]),
Wait1TurnandRestartScript(),
CastSpell(DrainSpell, FlameWallSpell, FlameWallSpell),
StartCounterCommands(),
IfHPBelow(0),
RunObjectSequence(3),
IncreaseVarBy1(BV7EE00E),
RemoveTarget(SELF),
Wait1TurnandRestartScript(),
IfTargetedByCommand([COMMAND_ATTACK]),
SetVarBits(BV7EE00F, [0]),
Attack(Attack0, DoNothing, DoNothing),
ClearVarBits(BV7EE00F, [0]),
Wait1TurnandRestartScript()
])
```
You can Ctrl+F the name of a command in Lazy Shell in src/smrpgpatchbuilder/datatypes/monster_scripts to find the documentation for how to use that command in Python.
<sub>([back to top](#how-this-works))</sub>
### Monster attacks
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py enemyattackdisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py enemyattackassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/enemy_attacks/attacks.py
```
The disassembler creates an `EnemyAttackCollection` (in the same file) that instantiates all of your EnemyAttack classes. If you want to use these attacks in another Python project, you'll need to import the `EnemyAttackCollection`. To prepare the patch data, run `collection.render()` to get a `dict[int, bytearray]` where each `int` is a ROM address to which the `bytearray` should be patched.
<sub>([back to top](#how-this-works))</sub>
### Monster and ally spells
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py spelldisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py spellassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/spells/spells.py
```
The disassembler creates a `SpellCollection` (in the same file) that instantiates all of your Spell classes. If you want to use these spells in another Python project, you'll need to import the `SpellCollection`. To prepare the patch data, run `collection.render()` to get a `dict[int, bytearray]` where each `int` is a ROM address to which the `bytearray` should be patched.
<sub>([back to top](#how-this-works))</sub>
### Allies
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py spelldisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py spellassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/allies/allies.py
```
The disassembler creates an `AllyCollection` that instantiates all five of your allies. If you want to use these characters in another Python project, you'll need to import the `AllyCollection`. To prepare the patch data, run `collection.render()` to get a `dict[int, bytearray]` where each `int` is a ROM address to which the `bytearray` should be patched.
Allies look like this:
```python
MARIO_Ally = Ally(
index=0,
name="Mario",
starting_level=1,
starting_current_hp=20,
starting_max_hp=20,
starting_speed=20,
starting_attack=20,
starting_defense=0,
starting_mg_attack=10,
starting_mg_defense=2,
starting_experience=0,
starting_weapon=None,
starting_armor=None,
starting_accessory=None,
starting_magic=[
JumpSpell,
],
levels=[
LevelUp(
level=2,
exp_needed=16,
spell_learned=None,
hp_plus=5,
attack_plus=3,
defense_plus=2,
mg_attack_plus=2,
mg_defense_plus=2,
hp_plus_bonus=3,
attack_plus_bonus=1,
defense_plus_bonus=1,
mg_attack_plus_bonus=3,
mg_defense_plus_bonus=1,
),
...
],
coordinates=AllyCoordinate(
cursor_x=1,
cursor_y=3,
sprite_abxy_y=191,
cursor_x_scarecrow=1,
cursor_y_scarecrow=3,
sprite_abxy_y_scarecrow=192,
)
)
```
where `coordinates` controls where the cursor and ABXY buttons will appear relative to their sprites in battle (the rest of the properties should be self explanatory).
The assembler can rename your characters, but be aware that it will not change the point at which their names get cut off in the shop menu (such as when looking at who can equip an item). The renaming will also apply to the levelup screen, but their names will be written to 0x2F9B0 instead of 0x2D3AF (to be more forgiving with space for longer names). This assumes that you haven't added anything to the ROM at 0x2F9B0.
<sub>([back to top](#how-this-works))</sub>
### Items
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py itemdisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py itemassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/items.items.py
```
Examples - NokNokShell, Muku Cookie, and Fire Bomb:
  
```python
class NokNokShellItem(Weapon):
"""NokNok Shell item class"""
_item_name: str = "NokNok Shell"
_prefix = ItemPrefix.SHELL
_item_id: int = 7
_description: str = " Kick to attack"
_equip_chars: List[PartyCharacter] = [MARIO]
_attack: int = 20
_variance: int = 2
_price: int = 20
_hide_damage: bool = True
_half_time_window_begins = UInt8(20)
_perfect_window_begins = UInt8(25)
_perfect_window_ends = UInt8(31)
_half_time_window_ends = UInt8(36)
class MukuCookieItem(RegularItem):
"""Muku Cookie item class"""
_item_name: str = "Muku Cookie"
_prefix = ItemPrefix.DOT
_item_id: int = 120
_description: str = " Muku! Muku-\n muku! Muka?"
_inflict: int = 69
_price: int = 69
_effect_type = EffectType.NULLIFICATION
_hide_damage: bool = True
_usable_battle: bool = True
_overworld_menu_fill_fp: bool = True
_target_all: bool = True
_one_side_only: bool = True
_status_immunities: List[Status] = [Status.MUTE, Status.SLEEP, Status.POISON, Status.FEAR, Status.BERSERK, Status.MUSHROOM, Status.SCARECROW]
class FireBombItem(RegularItem):
"""Fire Bomb item class"""
_item_name: str = "Fire Bomb"
_prefix = ItemPrefix.BOMB
_item_id: int = 113
_description: str = " Hit all\n enemies w/fire"
_inflict: int = 120
_price: int = 200
_inflict_element = Element.FIRE
_hide_damage: bool = True
_usable_battle: bool = True
_target_enemies: bool = True
_target_all: bool = True
_one_side_only: bool = True
```
It is assumed (for now) that the item subclass ranges are as follows:
- 0-36: weapons
- 37-73: armor
- 74-95: accessory
- 96-255: regular items
Almost everything that can be disassembled will need access to your item classes, so it's important for this to be one of the first things you do.
The disassembler creates an `ItemCollection` (in the same file) that instantiates all of your Item classes (this is necessary to create a ROM patch). If you want to use these items in another Python project, you'll need to import the `ItemCollection`. To prepare the patch data, run `itemcollection.render()` to get a `dict[int, bytearray]` where each `int` is a ROM address to which the `bytearray` should be patched.
<sub>([back to top](#how-this-works))</sub>
### Sprites
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py graphicsdisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py graphicsassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/sprites/sprites.py
```
NPC sprites use uncompressed tiles, an image pack, an animation pack, and a container that references all three of those things. These all exist in different parts of the ROM. The sprite disassembler combines all of these things into a single object (which is why you won't see animation or image pack IDs) so that the assembler can create and write that info to the rom in an optimized manner that prioritizes clearing up empty space for more tiles.
Palettes are not covered by the disassembler, you still need to use IDs for those.
Here is an example of a disassembled sprite:
```python
# SPR0524_EMPTY
from smrpgpatchbuilder.datatypes.graphics.classes import CompleteSprite, AnimationPack, AnimationPackProperties, AnimationSequence, AnimationSequenceFrame, Mold, Tile, Clone
sprite = CompleteSprite(
animation=AnimationPack(0, length=31, unknown=0x0002,
properties=AnimationPackProperties(vram_size=2048,
molds=[
Mold(0, gridplane=False,
tiles=[
Tile(mirror=False, invert=False, format=0, length=7, subtile_bytes=[
bytearray(b'\xff\xf0\xff\xc0\xff\x80\xff\x80\xff\x00\xff\x00\xff\x00\xff\x00\x0f\xff?\xff\x7f\xff~\xfe\xfe\xfe\xfe\xfe\xfe\xfe\xe0\xe0'),
bytearray(b'\xff\x0f\xff\x03\xff\x01\xff\x01\xff\x00\xff\x00\xff\x00\xff\x00\xf0\xff\xfc\xff\xfe\xff~\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x07\x07'),
bytearray(b'\xff\x00\xff\x00\xff\x00\xff\x00\xff\x80\xff\x80\xff\xc0\xff\xf0\xe0\xe0\xfe\xfe\xfe\xfe\xfe\xfe~\xfe\x7f\xff?\xff\x0f\xff'),
bytearray(b'\xff\x00\xff\x00\xff\x00\xff\x00\xff\x01\xff\x01\xff\x03\xff\x0f\x07\x07\x7f\x7f\x7f\x7f\x7f\x7f~\x7f\xfe\xff\xfc\xff\xf0\xff'),
], is_16bit=False, y_plus=0, y_minus=0, x=120, y=120),
]
),
],
sequences=[
AnimationSequence(
frames=[
AnimationSequenceFrame(duration=16, mold_id=0),
]
),
]
)
),
palette_id=0,
palette_offset=0,
unknown_num=8
)
```
Disassembly will produce a `SpriteCollection`. If you want to import your sprites into another Python project, this is what you should import. `collection.render()` produces a `list[tuple[int, bytearray]]` where each tuple is a ROM address and the bytes to patch to that address.
<sub>([back to top](#how-this-works))</sub>
### Shops
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py shopdisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py shopassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/shops/shops.py
```
which produces a `ShopCollection` of 33 shops. If you want to use your disassembled shops in another project, this is what your project should import. `ShopCollection.render()` produces a `dict[int, bytearray]` where each `int` is a ROM address where the corresponding `bytearray` is supposed to be patched.
Example shop:
```python
shops[SH06_FROG_COIN_EMPORIUM] = Shop(
index=6,
items=[
SleepyBombItem,
BracerItem,
EnergizerItem,
CrystallineItem,
PowerBlastItem,
],
buy_frog_coin=True,
)
```
<sub>([back to top](#how-this-works))</sub>
### Overworld dialogs
Disassemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py dialogdisassembler --rom "path/to/your/smrpg/rom"
```
Assemble:
```bash
PYTHONPATH=src python src/smrpgpatchbuilder/manage.py dialogassembler -r path/to/your/smrpg/rom -t -b
# -r generates a ROM patch, -t generates a text file, -b generates a FlexHEX .bin
```
Writes to:
```
./src/disassembler_output/dialogs/dialogs.py
```
which produces a `DialogCollection`. If you want to use your disassembled dialogs in another project, this is what your project should import. `DialogCollection.render()` produces a `dict[int, bytearray]` where each `int` is a ROM address where the corresponding `bytearray` is supposed to be patched.
Dialogs in SMRPG are split in | text/markdown | null | pidgezero_one <s.kischak@gmail.com> | null | null | null | null | [
"Programming Language :: Python :: 3",
"Operating System :: OS Independent"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"Django==5.1.7"
] | [] | [] | [] | [
"Homepage, https://github.com/pidgezero-one/smrpgpatchbuilder",
"Issues, https://github.com/pidgezero-one/smrpgpatchbuilder/issues"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:26:14.805500 | smrpgpatchbuilder-1.5.8.tar.gz | 528,588 | 36/e2/95646482e0a607db8e5e32fdc5735bf9234a9569038e5feb9f7257d3d96d/smrpgpatchbuilder-1.5.8.tar.gz | source | sdist | null | false | 4df4ef27a53485b774a000f1d5216e94 | 6488a8ced6461320b2ead8d38624ce272554ae9e1c021919d1d54a7a64d34d94 | 36e295646482e0a607db8e5e32fdc5735bf9234a9569038e5feb9f7257d3d96d | MIT | [
"LICENSE"
] | 264 |
2.4 | gemini-web-mcp-cli | 0.3.12 | MCP server and CLI for the Gemini web interface | <p align="center">
<img src="assets/banner.png" alt="Gemini Web MCP & CLI" width="800">
</p>
# gemini-web-mcp-cli
MCP server and CLI for the [Gemini web interface](https://gemini.google.com). Reverse-engineers the Gemini web UI's RPC protocol to provide programmatic access to all Gemini features.
## Features
- **Chat** with model selection (Gemini 3.0 Pro, Flash, Flash Thinking, and more)
- **File upload** for context in conversations (images, PDFs, documents, audio)
- **Interactive REPL** with slash commands, session persistence, and model switching
- **Image generation** via Nano Banana / Imagen
- **Video generation** via Veo 3.1
- **Music generation** via Lyria 3 with 16 style presets (8-bit, K-pop, Emo, Cinematic, and more)
- **Deep Research** with multi-source reports
- **Gems** management (custom system prompts)
- **Multi-profile** support with cross-product profile sharing (NotebookLM MCP)
- **MCP server** with 9 consolidated tools for AI agent integration
- **Skill system** to teach AI tools (Claude Code, Cursor, Codex, etc.) how to use gemcli
- **Hack Claude** — launch Claude Code powered by Gemini (`gemcli hack claude`)
- **API server** — local Anthropic-compatible API backed by Gemini
- **Diagnostics** (`gemcli doctor`) for installation, auth, and configuration checks
- **One-command setup** (`gemcli setup add <tool>`) for MCP client configuration
## Vibe Coding Alert
Full transparency: this project was built by a non-developer using AI coding assistants. If you're an experienced Python developer, you might look at this codebase and wince. That's okay.
The goal here was to learn — both about building CLI tools in Python and about how modern web applications work under the hood. The code works, but it's very much a learning project, not a polished product.
**If you know better, teach us.** PRs, issues, and architectural advice are all welcome. This is open source specifically because human expertise is irreplaceable.
> **Educational & Research Use:** This project reverse-engineers the Gemini web interface protocol for educational and research purposes. It is **not affiliated with, endorsed by, or sponsored by Google**. Use of this tool is at your own risk, and you are responsible for compliance with Google's [Terms of Service](https://policies.google.com/terms). The authors assume no liability for how this software is used.
## Installation
```bash
# With uv (recommended)
uv tool install gemini-web-mcp-cli
# With pip
pip install gemini-web-mcp-cli
# With pipx
pipx install gemini-web-mcp-cli
# Development
git clone https://github.com/jacob-bd/gemini-web-mcp-cli
cd gemini-web-mcp-cli
uv pip install -e ".[dev]"
```
### Upgrading
```bash
# With uv
uv cache clean && uv tool install --force gemini-web-mcp-cli
# With pip
pip install --no-cache-dir --upgrade gemini-web-mcp-cli
# With pipx
pipx upgrade gemini-web-mcp-cli
```
## Quick Start
### 1. Authenticate
```bash
gemcli login # Automated Chrome login via CDP
gemcli login --manual # Paste cookies manually
gemcli login --check # Validate current session
```
Automated login opens Chrome, navigates to gemini.google.com, and captures cookies via CDP. If you have a NotebookLM MCP profile, gemcli can reuse it automatically.
### 2. Chat
```bash
gemcli chat "What is the meaning of life?"
gemcli chat "Explain quantum computing" -m pro
gemcli chat "Summarize this" -o summary.md
gemcli chat # Interactive REPL
```
**Interactive REPL commands:**
| Command | Description |
|---------|-------------|
| `/model <name>` | Switch model (pro, flash, thinking) |
| `/verify` | Show server model hash |
| `/new` | Start new conversation |
| `/save <file>` | Export conversation |
| `/history` | View conversation turns |
| `/help` | Show help |
| `/quit` | Exit REPL |
### 3. Generate Images
```bash
gemcli image "A red panda wearing a top hat in a bamboo forest"
gemcli image "A futuristic city at sunset" -o city.png
```
### 4. Generate Videos
```bash
gemcli video "Ocean waves crashing on a rocky beach at sunset"
gemcli video "Dancing robot" -o robot.mp4
```
### 5. Generate Music (Lyria 3)
```bash
gemcli music "A comical R&B slow jam about a sock"
gemcli music "Cats playing video games" -s 8-bit -o track.mp3
gemcli music "Summer vibes" -s k-pop -o video.mp4 -f video
gemcli music --list-styles # Show all 16 style presets
```
**Available style presets:** 90s-rap, latin-pop, folk-ballad, 8-bit, workout, reggaeton, rnb-romance, kawaii-metal, cinematic, emo, afropop, forest-bath, k-pop, birthday-roast, folk-a-cappella, bad-music. Also accepts aliases like "rap", "metal", "ambient", "chiptune".
### 6. Deep Research
```bash
gemcli research "Latest advances in quantum computing 2026"
gemcli research "AI regulation landscape" -o report.md
```
### 7. File Upload (Chat with Attachments)
```bash
gemcli chat "Summarize this document" -f report.pdf
gemcli chat "What's in this image?" -f screenshot.png
gemcli chat "Compare these" -f file1.md -f file2.md
gemcli file upload document.pdf # Upload only, get identifier
```
Supported file types: images (PNG, JPEG, GIF, WebP), PDFs, documents, audio files. Files are uploaded via Google's resumable upload protocol and attached to the chat message automatically.
### 8. Hack Claude (Use Gemini in Claude Code)
```bash
gemcli hack claude # Launch Claude Code with Gemini Flash
gemcli hack claude --model gemini-pro # Use Gemini Pro
gemcli hack claude -p "fix this bug" # Pass args through to Claude Code
```
Automatically starts a local Anthropic-compatible API server backed by Gemini, configures Claude Code to use it, and cleans up when done. Requires `claude` CLI to be installed.
### 9. Manage Gems
```bash
gemcli gems list
gemcli gems create --name "Code Reviewer" --prompt "You are an expert code reviewer..."
gemcli gems delete <gem-id>
```
## Profile Management
```bash
gemcli profile list # List profiles
gemcli profile create work # Create new profile
gemcli profile switch work # Switch active profile
gemcli chat "hello" --profile work # Use specific profile
```
Cross-product profile sharing: gemcli automatically discovers profiles from NotebookLM MCP (`~/.notebooklm-mcp-cli/profiles/`). No copying — profiles are read live.
Environment variable: `GEMCLI_PROFILE=work` overrides the active profile.
## MCP Server Setup
Use `gemcli setup` to configure the MCP server for your AI tools in one command:
```bash
gemcli setup add cursor # Configure Cursor
gemcli setup add claude-code # Configure Claude Code
gemcli setup add claude-desktop # Configure Claude Desktop
gemcli setup add gemini-cli # Configure Gemini CLI
gemcli setup add windsurf # Configure Windsurf
gemcli setup add cline # Configure Cline
gemcli setup add antigravity # Configure Antigravity
gemcli setup list # Show configuration status
gemcli setup remove cursor # Remove configuration
```
Or add manually to your MCP client config:
```json
{
"mcpServers": {
"gemini-web-mcp": {
"command": "gemini-web-mcp",
"args": []
}
}
}
```
### Available MCP Tools
| Tool | Actions | Description |
|------|---------|-------------|
| `chat` | send | Conversations with model selection, extensions, and file attachments |
| `image` | generate, download | Image creation (Nano Banana / Imagen) |
| `video` | generate, status, download | Video creation (Veo 3.1) |
| `music` | generate, list_styles, download | Music generation (Lyria 3) with 16 style presets |
| `research` | start, status | Deep Research with reports |
| `gems` | list, create, update, delete | Custom Gem management |
| `canvas` | create, update, export | Canvas documents (coming soon) |
| `code` | execute, download | Python sandbox (coming soon) |
| `file` | upload | File uploads for conversation context |
## Skill System
Skills teach AI tools how to use gemcli effectively. Install a skill so your AI assistant knows all gemcli commands, workflows, and best practices.
```bash
gemcli skill install claude-code # Install for Claude Code
gemcli skill install cursor # Install for Cursor
gemcli skill install codex # Install for Codex (AGENTS.md format)
gemcli skill install gemini-cli # Install for Gemini CLI
gemcli skill list # Show installation status
gemcli skill update # Update all installed skills
gemcli skill show # Display skill documentation
gemcli skill uninstall claude-code # Remove a skill
```
**Supported tools:** claude-code, cursor, codex, opencode, gemini-cli, antigravity, cline, openclaw, other (exports all formats).
## Persistent Chrome (for background processes)
Music generation and Pro/Thinking models require Chrome for BotGuard token generation. If running from a background process (macOS LaunchAgent, cron, systemd), Chrome cannot be launched on demand. Start it once from an interactive terminal:
```bash
gemcli chrome start # Start headless Chrome daemon
gemcli chrome start --visible # Start with visible window
gemcli chrome status # Check health, port, auth status
gemcli chrome stop # Stop the daemon
```
The daemon runs headless, survives terminal close, and is automatically detected by Token Factory. After a reboot, run `gemcli chrome start` again.
**Which features need Chrome?**
| Feature | Chrome needed? |
|---------|---------------|
| Chat (Flash) | No |
| Chat (Pro/Thinking) | Yes |
| Chat with file attachments | Yes (BotGuard required) |
| Image generation | No |
| Video generation | No |
| Music generation | Yes (BotGuard required even on Flash) |
| Deep Research | No |
## Diagnostics
```bash
gemcli doctor # Check installation, auth, and configuration
gemcli doctor --verbose # Detailed diagnostics with paths and timestamps
```
The doctor command checks:
- Installation (gemcli and gemini-web-mcp binaries)
- Chrome (binary detection, saved profiles, persistent daemon status)
- Configuration (config directory, profiles, NotebookLM cross-product)
- Authentication (cookies and tokens for active profile)
- MCP clients (configuration status across all supported tools)
- Skills (installation status)
## Verb-First Aliases
Alternative command syntax for convenience:
```bash
gemcli list gems # = gemcli gems list
gemcli list profiles # = gemcli profile list
gemcli list skills # = gemcli skill list
gemcli create gem --name ... # = gemcli gems create --name ...
gemcli delete gem <id> # = gemcli gems delete <id>
gemcli install skill <tool> # = gemcli skill install <tool>
gemcli update skill [tool] # = gemcli skill update [tool]
```
## AI-Friendly Documentation
```bash
gemcli --ai # Print full AI-friendly docs to stdout
```
Outputs complete documentation in a format optimized for AI assistants to read and understand the full CLI and MCP tool surface.
## Architecture
```
src/gemini_web_mcp_cli/
core/ # RPC transport, auth, parsing (shared foundation)
services/ # Business logic (single source of truth)
data/ # Skill documentation (ships with package)
cli.py # CLI (Click) — thin wrapper over services
mcp.py # MCP server (FastMCP) — thin wrapper over services
setup.py # MCP client configuration helper
skill.py # Skill installer for AI tools
```
All interfaces (CLI, MCP, future API) consume the same service layer. When Gemini changes an RPC, you update one service file and everything works.
## Development
```bash
git clone https://github.com/jacob-bd/gemini-web-mcp-cli
cd gemini-web-mcp-cli
uv venv && source .venv/bin/activate
uv pip install -e ".[dev]"
pytest tests/ -v # 308 tests
ruff check src/ tests/ # Lint
```
## Acknowledgments
Protocol knowledge informed by [HanaokaYuzu/Gemini-API](https://github.com/HanaokaYuzu/Gemini-API), an excellent reverse-engineering of the Gemini web interface. Clean-room rebuild following patterns from [notebooklm-mcp-cli](https://github.com/jacob-bd/notebooklm-mcp-cli) and [perplexity-web-mcp](https://github.com/jacob-bd/perplexity-web-mcp).
## License
MIT
| text/markdown | Jacob Ben David | null | null | null | null | ai, cli, gemini, google, mcp | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"click>=8.1",
"fastapi>=0.115",
"httpx[http2]>=0.27",
"loguru>=0.7",
"mcp[cli]>=1.0",
"orjson>=3.9",
"pillow>=10.0",
"pydantic>=2.0",
"rich>=13.0",
"uvicorn>=0.34",
"websocket-client>=1.7",
"websockets>=12.0",
"pytest-asyncio>=0.23; extra == \"all\"",
"pytest-cov>=4.0; extra == \"all\"",
"pytest>=8.0; extra == \"all\"",
"ruff>=0.3; extra == \"all\"",
"pytest-asyncio>=0.23; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.3; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/jacob-bd/gemini-web-mcp-cli",
"Repository, https://github.com/jacob-bd/gemini-web-mcp-cli",
"Issues, https://github.com/jacob-bd/gemini-web-mcp-cli/issues",
"Changelog, https://github.com/jacob-bd/gemini-web-mcp-cli/blob/main/CHANGELOG.md"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:26:01.040850 | gemini_web_mcp_cli-0.3.12.tar.gz | 5,201,341 | 8c/f9/42615c8bdcb055e503dc9c84442815deacfb01c9197d9badd19039e118e8/gemini_web_mcp_cli-0.3.12.tar.gz | source | sdist | null | false | 99ac8c78d974d3eb954a89247b3fa3cb | b466a63889f5b483baae7a270f5500f56b4443d340d64e0203f3d1fca9389494 | 8cf942615c8bdcb055e503dc9c84442815deacfb01c9197d9badd19039e118e8 | MIT | [] | 245 |
2.4 | isage | 0.2.4.19 | SAGE - Streaming-Augmented Generative Execution | # SAGE - Streaming-Augmented Generative Execution
SAGE (Streaming-Augmented Generative Execution) 是一个强大的分布式流数据处理平台的 Meta 包。
## ⚠️ PEP 420 Namespace Package
**CRITICAL**: SAGE 使用 PEP 420 namespace packages 架构。
```python
# ❌ 错误：不能直接导入 sage 命名空间
import sage
# ✅ 正确：导入具体的子包
import sage.common
import sage.kernel
import sage.middleware
from sage.common.config import get_user_paths
# 注意: sage.llm 已移至独立仓库 isagellm
# pip install isagellm
```
**为什么不能直接 `import sage`?**
- SAGE 采用 PEP 420 原生命名空间（无 `__init__.py`）
- 允许多个独立 PyPI 包共享 `sage.*` 命名空间
- 防止"命名空间劫持"（首个安装包独占 `sage/`）
- 符合现代 Python 标准（Python 3.3+）
**相关**: #1388 多仓库拆分准备
## 简介
这是 SAGE 的主要元包，提供分层的安装选项以适应不同使用场景。
## 🧭 Governance / 团队协作制度
本包的团队安排、负责人制度、协作流程与质量门槛见：
- `docs/governance/TEAM.md`
- `docs/governance/MAINTAINERS.md`
- `docs/governance/DEVELOPER_GUIDE.md`
- `docs/governance/PR_CHECKLIST.md`
- `docs/governance/SELF_HOSTED_RUNNER.md`
- `docs/governance/TODO.md`
## 🎯 安装方式
### 标准安装（推荐）✅
日常应用开发，包含核心功能 + CLI + Web UI + RAG/LLM operators
```bash
pip install isage
```
**包含组件**：
- **L1-L4**: 核心运行时、算法库、领域算子
- **L5**: CLI 工具 (`sage` 命令) + 开发工具
**独立仓库** (不在 SAGE 核心架构中):
- sage-benchmark - 基准测试
- sage-examples - 应用示例
- sage-studio - Web UI
- sageLLM - LLM 推理引擎
- **科学计算库**: numpy, pandas, matplotlib, scipy, jupyter
**大小**: ~200MB | **适合**: 应用开发者、日常使用
______________________________________________________________________
### 其他安装选项
#### 核心运行时
仅用于运行已有 pipeline（生产环境、容器部署）
```bash
pip install isage[core]
```
**大小**: ~100MB | **适合**: 生产部署
#### 完整功能
包含示例应用（医疗、视频）和性能测试工具
```bash
pip install isage[full]
```
**大小**: ~300MB | **适合**: 学习示例、性能评估
#### 框架开发
修改 SAGE 框架源代码
```bash
pip install isage[dev]
```
**大小**: ~400MB | **适合**: 框架贡献者
## 📦 包含的组件
### 默认安装 (standard)
- **isage-common** (L1): 基础工具和公共模块
- **isage-platform** (L2): 平台服务（队列、存储）
- **isage-kernel** (L3): 核心运行时和任务执行引擎
- **isage-libs** (L3): 算法库和 Agent 框架
- **isage-middleware** (L4): RAG/LLM operators
- **isage-tools** (L5): CLI 工具 (`sage` 命令)
- **isage-cli** (L5): 生产 CLI 接口
### 额外组件 (独立仓库/PyPI 包)
- **isage-benchmark**: 性能基准测试工具 (独立仓库: sage-benchmark)
- **isagellm**: LLM 推理引擎 (独立仓库: sageLLM)
- **isage-edge**: 边缘聚合器 (独立仓库: sage-edge)
## 快速开始
### 安装
```bash
# 标准安装（推荐）
pip install isage
# 或从源码安装
git clone https://github.com/intellistream/SAGE.git
cd SAGE
pip install -e packages/sage
```
## 使用示例
```python
import sage
# 创建 SAGE 应用
app = sage.create_app()
# 定义数据流处理
@app.stream("user_events")
def process_events(event):
return {
"user_id": event["user_id"],
"processed_at": sage.now(),
"result": "processed",
}
# 启动应用
if __name__ == "__main__":
app.run()
```
## 命令行工具
安装后，你可以使用以下命令：
```bash
# 查看版本
sage --version
# 创建新项目
sage create my-project
# 启动服务
sage run
# 查看帮助
sage --help
```
## 文档
- [用户指南](https://intellistream.github.io/SAGE-Pub/)
- [API 文档](https://intellistream.github.io/SAGE-Pub/api/)
- [开发者指南](https://intellistream.github.io/SAGE-Pub/dev/)
## 许可证
MIT License
## 贡献
欢迎贡献代码！请查看我们的[贡献指南](CONTRIBUTING.md)。
## 支持
如果你遇到问题或有疑问，请：
1. 查看[文档](https://intellistream.github.io/SAGE-Pub/)
1. 搜索[已知问题](https://github.com/intellistream/SAGE/issues)
1. 创建[新问题](https://github.com/intellistream/SAGE/issues/new)
| text/markdown | null | SAGE Team <shuhao_zhang@hust.edu.cn> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: System :: Distributed Computing"
] | [] | null | null | ==3.11.* | [] | [] | [] | [
"isage-common>=0.2.4.13",
"isagellm>=0.5.1.2",
"isage-platform>=0.1.0",
"isage-kernel>=0.2.4.14",
"isage-libs>=0.1.0",
"isage-middleware>=0.1.0",
"isage-flownet>=0.1.0",
"isage-cli>=0.2.4.15",
"isage-tools>=0.1.0; extra == \"dev\"",
"pytest>=7.4.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"ruff==0.14.6; extra == \"dev\"",
"mypy>=1.7.0; extra == \"dev\"",
"pre-commit>=3.5.0; extra == \"dev\"",
"isage-pypi-publisher>=0.2.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/intellistream/SAGE",
"Documentation, https://intellistream.github.io/SAGE-Pub/",
"Repository, https://github.com/intellistream/SAGE.git",
"Bug Tracker, https://github.com/intellistream/SAGE/issues"
] | twine/6.2.0 CPython/3.11.11 | 2026-02-21T04:25:47.293077 | isage-0.2.4.19.tar.gz | 5,846 | 20/98/feb2b49f562b984f77be97a3b0368da449be1256392dc705c10e51984840/isage-0.2.4.19.tar.gz | source | sdist | null | false | a74c04e04f5ebab8a42385e8da3ca804 | 9088d6f00fbb960186a5334ed479bcafa6529c5a3e6ff937832e3b536314a148 | 2098feb2b49f562b984f77be97a3b0368da449be1256392dc705c10e51984840 | MIT | [] | 240 |
2.4 | isage-cli | 0.2.4.15 | SAGE Command Line Interface - Unified CLI for SAGE platform | # SAGE CLI
> **Unified Command Line Interface for SAGE Platform**
[](https://www.python.org/downloads/)
[](../../LICENSE)
SAGE CLI (`sage-cli`) is the unified command-line interface for the SAGE (Streaming-Augmented
Generative Execution) platform. It provides a comprehensive set of commands for managing clusters,
deploying applications, and developing with SAGE.
## 🧭 Governance / 团队协作制度
- `docs/governance/TEAM.md`
- `docs/governance/MAINTAINERS.md`
- `docs/governance/DEVELOPER_GUIDE.md`
- `docs/governance/PR_CHECKLIST.md`
- `docs/governance/SELF_HOSTED_RUNNER.md`
- `docs/governance/TODO.md`
## 📋 Overview
**SAGE CLI** is the unified command-line interface for SAGE platform, providing commands for:
- **Cluster Management**: Start/stop Flownet-based runtime clusters, manage head/worker nodes
- **LLM Services**: Launch and manage LLM inference services
- **Development**: Tools for testing, quality checks, and project management
- **Monitoring**: System diagnostics and status checks
## ✨ Features
- **Unified Interface**: Single `sage` command for all platform operations
- **Cluster Orchestration**: Full Flownet runtime lifecycle management
- **LLM Integration**: Start LLM services with automatic model loading
- **Interactive Chat**: Built-in chat interface for testing
- **Development Tools**: Via separate `sage-dev` command from sage-tools package
## 🚀 Installation
```bash
# From source
cd packages/sage-cli
pip install -e .
# Or install from PyPI (when published)
pip install sage-cli
```
## 📋 Command Structure
SAGE CLI organizes commands into two main categories:
### Platform Commands
Manage SAGE infrastructure and system components:
- `sage cluster` - Flownet runtime cluster management
- `sage head` - Head node management
- `sage worker` - Worker node management
- `sage job` - Job management
- `sage jobmanager` - JobManager service
- `sage config` - Configuration management
- `sage doctor` - System diagnostics
- `sage version` - Version information
- `sage extensions` - C++ extension management
### Application Commands
Application-level functionality:
- `sage llm` - LLM service management
- `sage chat` - Interactive chat interface
- `sage embedding` - Embedding service management
- `sage pipeline` - Pipeline builder
- `sage studio` - Visual pipeline editor
### Development Commands
**Note:** Development commands are provided by the `sage-tools` package separately via the
`sage-dev` command.
To use development tools:
```bash
# Install sage-tools (if not already installed)
pip install sage-tools
# Use sage-dev command
sage-dev quality check
sage-dev project test
sage-dev maintain doctor
```
Development command groups include:
- `sage-dev quality` - Code quality checks
- `sage-dev project` - Project management
- `sage-dev maintain` - Maintenance tools
- `sage-dev package` - Package management
- `sage-dev resource` - Resource management
- `sage-dev github` - GitHub utilities
## 📖 Quick Start
### Basic Commands
```bash
# Check system status
sage doctor
# View version
sage version
# Get help
sage --help
sage <command> --help
```
### Cluster Management
```bash
# Start a cluster
sage cluster start
# View cluster status
sage cluster status
# Stop cluster
sage cluster stop
```
### LLM Service
```bash
# Start LLM service
sage llm start --model Qwen/Qwen2.5-7B-Instruct
# Check status
sage llm status
# Interactive chat
sage chat
```
### Development Tools
For development commands, install `sage-tools`:
```bash
pip install sage-tools
# Run development checks
sage-dev quality check
# Run tests
sage-dev project test
```
## � Configuration
SAGE CLI reads configuration from:
- `~/.sage/config.yaml` - User configuration
- `./config/config.yaml` - Project configuration
- Environment variables: `SAGE_*`
```yaml
# config.yaml example
cluster:
head_node: localhost
workers: 4
llm:
model: Qwen/Qwen2.5-7B-Instruct
port: 8001
```
## 📦 Package Structure
```
sage-cli/
├── src/
│ └── sage/
│ └── cli/
│ ├── commands/ # Command implementations
│ ├── cluster/ # Cluster management
│ └── llm/ # LLM service commands
├── tests/
├── pyproject.toml
└── README.md
```
## 🧪 Testing
```bash
# Run CLI tests
pytest packages/sage-cli/tests/
# Test specific command
sage --help
sage cluster --help
# Run integration tests
sage-dev project test --package sage-cli
```
## �📚 Documentation
For detailed documentation, see:
- [SAGE Documentation](https://intellistream.github.io/SAGE)
- [Project Changelog](../../CHANGELOG.md)
## 🏗️ Architecture
SAGE CLI is part of the L5 (Interface Layer) in the SAGE architecture:
```
L1: sage-common (Foundation)
L2: sage-platform (Platform Core)
L3: sage-kernel, sage-libs
L4: sage-middleware
L5: sage-cli, sage-tools
├── sage-cli: Production CLI via `sage` command
└── sage-tools: Development tools via `sage-dev` command
```
**Independent Repositories:**
- sage-benchmark: Benchmark suites
- sage-examples: Applications and tutorials
- sage-studio: Visual interface
- sageLLM: LLM inference engine
**Command Separation:**
- **sage** (from sage-cli): User-facing production commands
- Platform: cluster, head, worker, job, jobmanager, config, doctor, version, extensions
- Apps: llm, chat, embedding, pipeline
- **sage-dev** (from sage-tools): Developer-only commands
- quality, project, maintain, package, resource, github
Both packages are independent and can be installed separately.
## 🤝 Contributing
Contributions are welcome! Please see [CONTRIBUTING.md](../../CONTRIBUTING.md) for guidelines.
## 📄 License
Apache License 2.0 - see [LICENSE](../../LICENSE) for details.
## 🔗 Related Packages
- `sage-tools` - Development tools and `sage-dev` commands
- `sage-platform` - SAGE platform core
- `sage-apps` - SAGE applications
- `sage-studio` - Visual pipeline editor
| text/markdown | null | IntelliStream Team <shuhao_zhang@hust.edu.cn> | null | null | MIT | sage, cli, command-line, streaming, ai | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12"
] | [] | null | null | ==3.11.* | [] | [] | [] | [
"typer<1.0.0,>=0.15.0",
"rich>=13.0.0",
"pyyaml>=6.0",
"python-dotenv<2.0.0,>=1.1.0",
"requests<3.0.0,>=2.32.0",
"httpx<1.0.0,>=0.28.0",
"colorama>=0.4.6",
"tabulate<1.0.0,>=0.9.0",
"pytest>=7.4.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"ruff==0.14.6; extra == \"dev\"",
"isage-pypi-publisher>=0.2.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/intellistream/SAGE",
"Documentation, https://intellistream.github.io/SAGE",
"Repository, https://github.com/intellistream/SAGE",
"Issues, https://github.com/intellistream/SAGE/issues"
] | twine/6.2.0 CPython/3.11.11 | 2026-02-21T04:25:33.580749 | isage_cli-0.2.4.15.tar.gz | 662,415 | 30/9e/05636f681341e2cdc784b447b13d8cbe445921ce84db2f2f815643866131/isage_cli-0.2.4.15.tar.gz | source | sdist | null | false | 503527445f267661af911f7bbfd24901 | ca10705cc9f43fdb5ba16af211a9cc6fbe98b6078ef14694bc6150a5df6b50f2 | 309e05636f681341e2cdc784b447b13d8cbe445921ce84db2f2f815643866131 | null | [] | 234 |
2.1 | odoo-addon-web-widget-remote-measure | 15.0.1.2.0.1 | Allows to connect to remote devices to record measures | .. image:: https://odoo-community.org/readme-banner-image
:target: https://odoo-community.org/get-involved?utm_source=readme
:alt: Odoo Community Association
============================
Remote Measure Devices Input
============================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:232d98c89db55217dac087bac3abc2dfe5c0de58990afd900e362e25b7bb738d
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/web_widget_remote_measure
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-web_widget_remote_measure
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
This module allows to input data from remote devices in your network. Currently, only
websockets devices are supported, but it can be extended for any protocol like
Webservices.
Other modules can extend this one in order to use the widget.
**Table of contents**
.. contents::
:local:
Configuration
=============
To configure your remote devices:
#. Go to *Settings > Technical > Devices > Remote devices*
#. Create a new one configuring the required info.
#. If the devices has an special port, set it up in the host data: e.g.: 10.1.1.2:3210
If you want to see the button in the top bar to set the user's remote device, you need
to have the "Show remote device button on navbar" group.
If you need the field to always be selected, you can use the ``always_selected``
attribute in the view definition, as shown in the following example:
.. code:: xml
<field name="field_float" widget="remote_measure" always_selected="1"/>
Usage
=====
The remote device has to be in the users network so their web clients can reach them.
In order to test a device you can:
#. Go to *Settings > Technical > Devices > Remote devices*
#. In the Kanban view you'll wich devices can be reached as they'll have a green dot in
their card.
#. Go to one of those and click *Edit*.
#. You can start measuring from the remote device in the *Test measure* field.
On the technical side, you can use the widget in your own `Float``. You'll need to
provide an uom field so records that aren't in that UoM don't measure from the device.
.. code:: xml
<field name="float_field" widget="remote_measure" options="{'remote_device_field': 'measure_device_id', 'uom_field': 'uom_id'}" />
The users are able to change their default remote device by using the button with the
balance icon set on the navbar.
Known issues / Roadmap
======================
Current support:
- Websockets connection
- F501 protocol on continuous message stream.
But this is a commonground to add:
- Other connection interfaces like Webservices APIs
- Other device protocols.
- Active device controls, la Tare, resets, etc.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20web_widget_remote_measure%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
~~~~~~~
* Tecnativa
Contributors
~~~~~~~~~~~~
* `Tecnativa <https://www.tecnativa.com>`_:
* David Vidal
* Sergio Teruel
* Carlos Roca
Maintainers
~~~~~~~~~~~
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
.. |maintainer-chienandalu| image:: https://github.com/chienandalu.png?size=40px
:target: https://github.com/chienandalu
:alt: chienandalu
Current `maintainer <https://odoo-community.org/page/maintainer-role>`__:
|maintainer-chienandalu|
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/web_widget_remote_measure>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:27.730162 | odoo_addon_web_widget_remote_measure-15.0.1.2.0.1-py3-none-any.whl | 42,827 | f1/30/95fcf3439ff85574e4557630bfe2f81a329c2de93806f1dfb6ec20e134fd/odoo_addon_web_widget_remote_measure-15.0.1.2.0.1-py3-none-any.whl | py3 | bdist_wheel | null | false | ee9a0aa153e90e51a97a502def4ad95b | 5e080c67f1f35f6a42f3faccc40631e0484d724900e99da2d66c1a5b75872a54 | f13095fcf3439ff85574e4557630bfe2f81a329c2de93806f1dfb6ec20e134fd | null | [] | 73 |
2.1 | odoo-addon-sale-stock-weighing | 15.0.1.0.0.3 | Weight assistant extension sales | =============================
Weighing assistant sales info
=============================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:c1ea8a0ef16e5fadaeb14a9d9782339a443c1b7f2a74ded01825d89003612f36
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/sale_stock_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-sale_stock_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Show sale order infos in the weighing assistant cards.
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20sale_stock_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/sale_stock_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:24.990150 | odoo_addon_sale_stock_weighing-15.0.1.0.0.3-py3-none-any.whl | 20,857 | ba/20/503b52bf0cce5ff620125ce3e22b5fdd074517598375e0001ecdd1185031/odoo_addon_sale_stock_weighing-15.0.1.0.0.3-py3-none-any.whl | py3 | bdist_wheel | null | false | 3c3b5d96817c7c167e696697c091b8ae | 9c35eefc86fd98d8cdcb20a381c777f821c5241189f13c0f0a5e304ef80266b1 | ba20503b52bf0cce5ff620125ce3e22b5fdd074517598375e0001ecdd1185031 | null | [] | 81 |
2.1 | odoo-addon-stock-weighing-threaded-print | 15.0.1.0.1.1 | Print labels on a different thread | ================================
Weighing deferred label printing
================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:fd56d20df0c519aa50f950595716ce53870bbe83d478806581f734aa4a54acda
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_threaded_print
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_weighing_threaded_print
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
This module is aimed to speed up the label printing process by returning the control of
the user's screen and triggering the printing in a background process. If something goes
wrong, the user is informed with a notification that can be used to retry the process.
**Table of contents**
.. contents::
:local:
Configuration
=============
The default behavior is to **print in main thread**, but it can be configured by
following these steps:
* Activate developer mode.
* Go to *Settings > Technical > Parameters > System Parameters*.
* Create a **stock_weighing_threaded_print.print_in_new_thread** key.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_weighing_threaded_print%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
~~~~~~~
* Tecnativa
Contributors
~~~~~~~~~~~~
* `Tecnativa <https://www.tecnativa.com>`_:
* Sergio Teruel
* David Vidal
Maintainers
~~~~~~~~~~~
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_threaded_print>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3",
"Development Status :: 4 - Beta"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-base_report_to_printer<15.1dev,>=15.0dev",
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo-addon-web_notify<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:23.062021 | odoo_addon_stock_weighing_threaded_print-15.0.1.0.1.1-py3-none-any.whl | 23,760 | 13/e5/e8018c6caa34374ef74c0be5179d223e952b88ae4ad1fa0c423753a6fa87/odoo_addon_stock_weighing_threaded_print-15.0.1.0.1.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 9b889dee4e480fcfc100e632d0ca1681 | 7cf908d35e7b3d047ad7905999bf6d2ade8a2d881d5cad9a2a44330a3869519e | 13e5e8018c6caa34374ef74c0be5179d223e952b88ae4ad1fa0c423753a6fa87 | null | [] | 77 |
2.1 | odoo-addon-stock-weighing-remote-measure | 15.0.1.1.0.1 | Gather the operations weights remotely | .. image:: https://odoo-community.org/readme-banner-image
:target: https://odoo-community.org/get-involved?utm_source=readme
:alt: Odoo Community Association
=================================
Weighing assistant remote measure
=================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:907021c29addfca98bbf40d695ea27b7a9d202eed83e86ee61d7b84037d6e23f
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_remote_measure
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_weighing_remote_measure
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Meausure the weight remotely from the weighing assistant.
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_weighing_remote_measure%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_remote_measure>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo-addon-web_widget_remote_measure<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:21.081848 | odoo_addon_stock_weighing_remote_measure-15.0.1.1.0.1-py3-none-any.whl | 27,628 | d7/59/81a492d782e54eec8ba7e3b46912f2191f6c1a6f6a57c9d7cd844afe0aa3/odoo_addon_stock_weighing_remote_measure-15.0.1.1.0.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 9b166b1129a5fe663c8c022d763ee66e | 76b9ebafaa5fa1a14076974e6a7bcbd67eea8f9650f7c810e23a00e245c4f573 | d75981a492d782e54eec8ba7e3b46912f2191f6c1a6f6a57c9d7cd844afe0aa3 | null | [] | 76 |
2.1 | odoo-addon-stock-weighing-auto-create-lot | 15.0.1.0.0.6 | Allow to create lots from the weighing kanban cards | ==================================
Weighing assistant auto create lot
==================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:f2d1351dcd82f7bcebd36043de934ede82f7a7da93e7b5fcd5d0cf96411f417c
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_auto_create_lot
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_weighing_auto_create_lot
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Auto-create lots when adding detailed operations from the weight kanban
card.
**Table of contents**
.. contents::
:local:
Configuration
=============
You need to allow to auto-create lots in your operation type. Doing so,
you'll be able to auto-assign a lot when creating a new operation from
the weighing card.
Remeber that you need to go to *Inventory > Configuration > Operation
Types* and set *Auto Create Lot* on in the type you want to.
Also take into account that only products with the *Auto Create Lot*
flag will have this feature. Set it on on the product's form
traceability options.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_weighing_auto_create_lot%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_auto_create_lot>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3",
"Development Status :: 4 - Beta"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_picking_auto_create_lot<15.1dev,>=15.0dev",
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:19.125541 | odoo_addon_stock_weighing_auto_create_lot-15.0.1.0.0.6-py3-none-any.whl | 24,797 | 41/d0/ba7e6a1f69f04ea962a22c8466d741e1b05fec7b2c725717238e9aebfc83/odoo_addon_stock_weighing_auto_create_lot-15.0.1.0.0.6-py3-none-any.whl | py3 | bdist_wheel | null | false | 1d61c35a2b1b9f68db0f1fc831f8fea8 | e8b9f73799e9e706ebe22b4213b16c09b481eac86c21f4e9a8b1c169d72493cd | 41d0ba7e6a1f69f04ea962a22c8466d741e1b05fec7b2c725717238e9aebfc83 | null | [] | 79 |
2.1 | odoo-addon-stock-weighing-auto-package | 15.0.1.1.0.4 | Auto create package for every weighing operation | =====================
Weighing auto package
=====================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:19e18e49d6ac0647be4e450613bdd841014542a528c1562369ed7e4b64801bd7
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_auto_package
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_weighing_auto_package
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Add auto package creator in weighing operations
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_weighing_auto_package%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
~~~~~~~
* Tecnativa
Contributors
~~~~~~~~~~~~
* `Tecnativa <https://www.tecnativa.com>`_:
* Sergio Teruel
* Carlor Dauden
Maintainers
~~~~~~~~~~~
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing_auto_package>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3",
"Development Status :: 4 - Beta"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:17.270403 | odoo_addon_stock_weighing_auto_package-15.0.1.1.0.4-py3-none-any.whl | 23,655 | 7b/94/fab2f834e40ecc254436d33f7ae28c65a6d7fccaecfcf256a2f38af4a1bb/odoo_addon_stock_weighing_auto_package-15.0.1.1.0.4-py3-none-any.whl | py3 | bdist_wheel | null | false | 402fc1944680070908cb8e85a10eca7e | a1ea36d2a99301dd7a85849a7c5262fa803425d924f310019dffacfa29cec360 | 7b94fab2f834e40ecc254436d33f7ae28c65a6d7fccaecfcf256a2f38af4a1bb | null | [] | 76 |
2.1 | odoo-addon-mrp-weighing | 15.0.1.0.1.1 | Launch the weighing assistant from batch pickings | ====================================
Weighing assistant in batch pickings
====================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:5135c6ce13fdaa318feadfc3a0d5155862465c45f440fdf149b8007aba2477bb
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/mrp_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-mrp_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Weighing production finished moves
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20mrp_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- Sergio Teruel
- Carlos Dauden
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/mrp_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:15.265858 | odoo_addon_mrp_weighing-15.0.1.0.1.1-py3-none-any.whl | 24,222 | e2/f0/992e63b173b03e35a5bbd2d3087327b34f77fd2081af2b9211d90f8e6cb2/odoo_addon_mrp_weighing-15.0.1.0.1.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 837d6c46b8dace754e09e9932c70a90e | 5d43abf77b33d90b0e22392e38b3fade3f150b7c21f3f3b600e0dab325dc02d2 | e2f0992e63b173b03e35a5bbd2d3087327b34f77fd2081af2b9211d90f8e6cb2 | null | [] | 78 |
2.1 | odoo-addon-sale-elaboration-weighing | 15.0.1.0.0.3 | Weighing assistant extension for elaborations | ===============================
Weighing assistant elaborations
===============================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:df470655f6d47aac916f46405de9d22f312856e4a3d6b3fea91544ac82c348a4
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/sale_elaboration_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-sale_elaboration_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Show elaborations information and filters in the weighing assistant.
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20sale_elaboration_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/sale_elaboration_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-sale_elaboration<15.1dev,>=15.0dev",
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:12.853041 | odoo_addon_sale_elaboration_weighing-15.0.1.0.0.3-py3-none-any.whl | 23,733 | 30/05/fce6e9df25549c9938206f9ae369e33231819db958b26b1c06898691248e/odoo_addon_sale_elaboration_weighing-15.0.1.0.0.3-py3-none-any.whl | py3 | bdist_wheel | null | false | 244146c1ce31c9231af24aebd254b0d9 | 3bbb46b34e906e82fc483712ee3f50409ce6d17533a4783bad5330b1df7ce88c | 3005fce6e9df25549c9938206f9ae369e33231819db958b26b1c06898691248e | null | [] | 78 |
2.1 | odoo-addon-web-widget-remote-measure-utilcell | 15.0.1.0.0.3 | Compatibility with UTILCELL propietary protocols | ======================
Remote UTILCELL scales
======================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:7e2437d3105f13250a9900f0978d5ff05c6a7454159bca3c0cd68b147e3ba630
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/web_widget_remote_measure_utilcell
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-web_widget_remote_measure_utilcell
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Utilcell scale protocols to be used with a remote measure device.
**Table of contents**
.. contents::
:local:
Configuration
=============
To configure this remote device, just go the remote measure device
configurtion form and set the desired protocol.
For the type of connection only direct tcp is supported right now for
these devices as they don't offer another possibility. Make sure your
Odoo instance has network visibility with the scale devices.
Known issues / Roadmap
======================
- There are more Utilcell protocols that we're not covering right now,
but they could be added easily, just check the scale technical docs.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20web_widget_remote_measure_utilcell%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__:
- David Vidal
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
.. |maintainer-chienandalu| image:: https://github.com/chienandalu.png?size=40px
:target: https://github.com/chienandalu
:alt: chienandalu
Current `maintainer <https://odoo-community.org/page/maintainer-role>`__:
|maintainer-chienandalu|
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/web_widget_remote_measure_utilcell>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-web_widget_remote_measure<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:09.825765 | odoo_addon_web_widget_remote_measure_utilcell-15.0.1.0.0.3-py3-none-any.whl | 2,481,476 | 7b/73/b211f16dede71b82f7f262a04a7eb265cb8fc85737ae32f40a85272e7916/odoo_addon_web_widget_remote_measure_utilcell-15.0.1.0.0.3-py3-none-any.whl | py3 | bdist_wheel | null | false | 6221ec651c3c0d145ee6a8dafeacdcf7 | 51a87517dbc3b9d5aee6874852cdf57be147b5119fa2a68917e5ad5feac1d34c | 7b73b211f16dede71b82f7f262a04a7eb265cb8fc85737ae32f40a85272e7916 | null | [] | 71 |
2.1 | odoo-addon-stock-secondary-unit-weighing | 15.0.1.0.0.4 | Show secondary unit info in the weighing assistant | ======================================
Weighing assistant and secondary units
======================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:39972d57a16d9c70efa8e83347e564184ee9fd0afd9d9dc90618fc4478a81e09
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_secondary_unit_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_secondary_unit_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Show secondary unit infos in the weighing assistant.
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_secondary_unit_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_secondary_unit_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_secondary_unit<15.1dev,>=15.0dev",
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:07.041768 | odoo_addon_stock_secondary_unit_weighing-15.0.1.0.0.4-py3-none-any.whl | 22,785 | 53/e2/60177fa7dcc001c7901db8513551ab853b476bfd7a5e112dba6d6b4688d4/odoo_addon_stock_secondary_unit_weighing-15.0.1.0.0.4-py3-none-any.whl | py3 | bdist_wheel | null | false | 5abae7f0447eb5b3367e81e6efe1b58e | 1e6979c73992da49d6e12ad24828f9a80d3df7a3f5f6725e6d90d4b7f56b7258 | 53e260177fa7dcc001c7901db8513551ab853b476bfd7a5e112dba6d6b4688d4 | null | [] | 78 |
2.1 | odoo-addon-partner-delivery-zone-weighing | 15.0.1.0.0.3 | Show delivery zones info in weighings | ======================================
Weighing assistant with delivery zones
======================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:513a9e1c0de66d20f15db63c968de08193639712d416ae587c7314d8ffcbace7
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/partner_delivery_zone_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-partner_delivery_zone_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
Shows delivery zone info in weighing cards.
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20partner_delivery_zone_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/partner_delivery_zone_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-partner_delivery_zone<15.1dev,>=15.0dev",
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:04.854900 | odoo_addon_partner_delivery_zone_weighing-15.0.1.0.0.3-py3-none-any.whl | 20,446 | 12/95/0bc6a5f4f4b584826f6cd2ff09a10b805d067734302ade03197002b3efbc/odoo_addon_partner_delivery_zone_weighing-15.0.1.0.0.3-py3-none-any.whl | py3 | bdist_wheel | null | false | ce16c3e26f66ca1084acc8739e317145 | e03f2a37ab7bb605d190a2d9a2bdf29b7df93c8fc2c1f3843b5ca004abdabccf | 12950bc6a5f4f4b584826f6cd2ff09a10b805d067734302ade03197002b3efbc | null | [] | 77 |
2.1 | odoo-addon-stock-weighing | 15.0.2.3.2.1 | Weighing assistant for stock operations | .. image:: https://odoo-community.org/readme-banner-image
:target: https://odoo-community.org/get-involved?utm_source=readme
:alt: Odoo Community Association
==================
Weighing assistant
==================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:064c3ab44b2d3fbc41d72d713249eef9964da3aeb5347bd039471738e6a48e98
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
A shopfloor assistant for weighing on stock operations.
**Table of contents**
.. contents::
:local:
Use Cases / Context
===================
Some bussiness must weigh their operations in order to process them. For
example in fresh product factories where the demand could not fit the
exact a amount of delivered product and that depends on the final
operation weight.
Configuration
=============
You need to configure an operation type so its operations show up in the
weighing assistant.
To do so:
1. Go to *Configuration > Operations Types* and choose the one you want
to configure.
2. Set *Weighing operations* on.
3. You can choose your desired *Weighing lable report*.
4. If you want to print your labels automatically, set *Print weighing
label* on.
If you don't have any product with units of measure of the weight
category, you'll have to add some.
- Allow to show the units of measure in your config settings if isn't
ready yet.
- Add some products with a unit of measure of the weight category
(kilograms, grams, etc.).
- Place some pending operations for those products.
If you want to use the weighing system for other operations you can set
the configuration parameter ``stock_weighing.any_operation_actions`` to
a true value. You'll be a able to record other values.
Usage
=====
You've got several ways to start weighing pending operations:
**From the app menu**
1. Go to the app menu an click on *Weighing*
2. You'll be presented with your weighing options (Incoming, Outgoing or
more if a third module extends it)
3. You can start weighing.
**From a weighing operation type**
1. Go to *Inventory > Overview*.
2. Those operation types with *weighing operation* active will show a
button with the pending ones.
3. Click on it and you can start weighing.
**From a picking**
1. In any picking with weighing operations, you can click on the smart
button and start processing them.
Using the assitant
------------------
You'll be presented with a list of operations to weigh. To weigh them,
just press the red circle button to record a new weight:
- If there's only one detailed operation reserved, a popup will show up
to record the operation weight.
- If there are several, you'll enter the detailed view and you'll be
able to weigh every detailed operation.
- If you just want to weigh one, you can force the operation as done
using the checkmark button.
You can reset your weighing using the cross button. You can print the
label on demand using the printer button. You can add a new detailed
operation using the plus button.
Known issues / Roadmap
======================
- This PR should be https://github.com/odoo/odoo/pull/161042 merged in
order to reload the kanban view properly after each action. Otherwise
we should reimplement the whole core method in our override.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-web_filter_header_button<15.1dev,>=15.0dev",
"odoo-addon-web_ir_actions_act_multi<15.1dev,>=15.0dev",
"odoo-addon-web_widget_numeric_step<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:24:02.241481 | odoo_addon_stock_weighing-15.0.2.3.2.1-py3-none-any.whl | 65,241 | 64/9d/7501950c259e13351fbf9cd0c15241b2a83bd6cba67a3a8d759dc5366c15/odoo_addon_stock_weighing-15.0.2.3.2.1-py3-none-any.whl | py3 | bdist_wheel | null | false | d3f8c4830db89dba75cdb6ba0b309081 | a0081f72ebd422775c33427b57ef6b2a11788d20aab698c355b39c7d3a95d688 | 649d7501950c259e13351fbf9cd0c15241b2a83bd6cba67a3a8d759dc5366c15 | null | [] | 96 |
2.1 | odoo-addon-stock-picking-batch-weighing | 15.0.1.0.1.1 | Launch the weighing assistant from batch pickings | ====================================
Weighing assistant in batch pickings
====================================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:4db8fbd8cb4b3af45ebf59e09fd45cd4eae22a1d998e3319584e8ca460cee355
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/licence-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fstock--weighing-lightgray.png?logo=github
:target: https://github.com/OCA/stock-weighing/tree/15.0/stock_picking_batch_weighing
:alt: OCA/stock-weighing
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/stock-weighing-15-0/stock-weighing-15-0-stock_picking_batch_weighing
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/stock-weighing&target_branch=15.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
We can go to the weighing operations from an action button in the batch
picking form.
**Table of contents**
.. contents::
:local:
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/stock-weighing/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/stock-weighing/issues/new?body=module:%20stock_picking_batch_weighing%0Aversion:%2015.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Tecnativa
Contributors
------------
- `Tecnativa <https://www.tecnativa.com>`__
- David Vidal
- Sergio Teruel
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/stock-weighing <https://github.com/OCA/stock-weighing/tree/15.0/stock_picking_batch_weighing>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Tecnativa, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 15.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/stock-weighing | null | >=3.8 | [] | [] | [] | [
"odoo-addon-stock_weighing<15.1dev,>=15.0dev",
"odoo<15.1dev,>=15.0a"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-21T04:23:59.745977 | odoo_addon_stock_picking_batch_weighing-15.0.1.0.1.1-py3-none-any.whl | 24,552 | fa/70/fc52fa43ce58b2a0f42f014b489280145c7631848daf5b3c2fbb8b888862/odoo_addon_stock_picking_batch_weighing-15.0.1.0.1.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 42379ff763fbc94ca21a27463c77a43c | 4fefe05894b98559566f2ac88f015cdaf65bb0831b00da4e534ecdab1fa074ba | fa70fc52fa43ce58b2a0f42f014b489280145c7631848daf5b3c2fbb8b888862 | null | [] | 79 |
2.4 | mycontext-ai | 0.2.1 | Universal Context Transformation Engine - 85 Research-Backed Cognitive Patterns (16 Free + 69 Enterprise) | # mycontext-ai
<div align="center">
**Context engineering for LLMs. Build once, run anywhere, measure everything.**
[](https://www.python.org/downloads/)
[](https://pypi.org/project/mycontext-ai/)
[](https://opensource.org/licenses/MIT)
[The Problem](#the-problem) · [Core Strengths](#core-strengths) · [Quick Start](#quick-start) · [Use Cases](#use-cases) · [Patterns](#85-cognitive-patterns)
</div>
---
## The Problem
Every team building with LLMs hits the same wall:
- **Prompt roulette.** You tweak wording for hours. Sometimes it works, sometimes it doesn't. There's no way to know *why*.
- **Vendor lock-in.** Your prompts are written for OpenAI. Now the team wants Claude. Rewrite everything.
- **No structure.** System messages, user messages, constraints, output format — every developer invents their own convention.
- **No measurement.** Is this prompt good? Better than yesterday's? Nobody knows until production breaks.
- **Reinventing the wheel.** Root cause analysis, decision frameworks, comparative reasoning — proven cognitive methods exist, but teams write ad-hoc prompts from scratch every time.
- **No way to prove templates help.** You built a prompt template, but can you *prove* it produces better output than a raw question?
## How It Works
mycontext-ai gives you a **structured `Context` object** that separates *what the AI should know* (guidance) from *what it should do* (directive) and *what it must not do* (constraints). You build the context once and export it to any LLM or framework.
```
Raw question
↓
[ Intelligence Layer ] — auto-selects the right cognitive pattern
↓
Structured Context (Guidance + Directive + Constraints)
↓
Export: OpenAI │ Anthropic │ Gemini │ LangChain │ YAML │ 13 formats
↓
[ Quality Metrics ] — score, compare, improve
↓
[ CAI ] — prove the template made a measurable difference
```
The engine doesn't generate answers. It generates the *best possible question* for the LLM you're sending it to — and it can *prove* it.
---
## Core Strengths
These are capabilities that exist in mycontext-ai and, to our knowledge, do not exist in any other open-source context or prompt engineering library.
### 1. 85 Research-Backed Cognitive Patterns
Not generic "write a poem" templates. Each pattern implements a real cognitive framework — Five Whys, fishbone analysis, Socratic method, temporal reasoning, systems archetypes, ethical frameworks — backed by **150+ peer-reviewed papers** from cognitive science, decision theory, and systems thinking.
Every pattern has a structured `build_context()` method with validated inputs, a research-grounded directive, and constraints tuned for the method.
```python
from mycontext.templates.free.decision import DecisionFramework
ctx = DecisionFramework().build_context(
decision="Choose database for new service",
options=["Postgres", "MongoDB", "DynamoDB"],
depth="comprehensive",
)
```
### 2. Quality Metrics — Score Any Context on 6 Dimensions
No more guessing. `QualityMetrics` evaluates any context across six calibrated dimensions: **clarity, completeness, specificity, relevance, structure, efficiency**. Returns a numeric score, concrete issues, strengths, and actionable suggestions.
Compare two contexts to measure improvement:
```python
from mycontext.intelligence import QualityMetrics
metrics = QualityMetrics()
score = metrics.evaluate(ctx)
print(metrics.report(score))
# → Overall: 0.87 | Clarity: 0.92 | Completeness: 0.85 | ...
# → Issues: ["Directive could be more specific about output format"]
# → Suggestions: ["Add constraints for response length"]
# Compare before/after
diff = metrics.compare(old_ctx, new_ctx)
```
### 3. Context Amplification Index (CAI) — Prove Templates Work
CAI is a quantitative metric that answers: *"Did this template actually produce better LLM output than a raw prompt?"*
It runs the same question through a raw prompt and a template-built context, evaluates both outputs, and computes the ratio:
**CAI = templated_score / raw_score**
A CAI of 1.3x means the template produced 30% better output. No opinions — numbers.
```python
from mycontext.intelligence import ContextAmplificationIndex
cai = ContextAmplificationIndex(provider="openai")
result = cai.measure(
question="Why are API response times 3x slower after deploy?",
template_name="diagnostic_root_cause_analyzer",
)
print(f"CAI: {result.cai_overall:.2f}x ({result.verdict})")
# → CAI: 1.42x (significant lift)
```
### 4. Output Evaluator — Score LLM Responses, Not Just Prompts
Other tools score prompts. mycontext also scores the *output*. The Output Evaluator measures LLM responses across five dimensions that are distinct from prompt quality:
- **Instruction Following** — did it do what the context asked?
- **Reasoning Depth** — shallow bullet points or genuine analysis?
- **Actionability** — can you act on the recommendations?
- **Structure Compliance** — did it follow the requested format?
- **Cognitive Scaffolding** — did it use the reasoning framework from the template?
```python
from mycontext.intelligence import OutputEvaluator, OutputDimension
evaluator = OutputEvaluator()
score = evaluator.evaluate(ctx, llm_response)
print(f"Output quality: {score.overall:.2f}")
print(f"Reasoning depth: {score.dimensions[OutputDimension.REASONING_DEPTH]:.2f}")
```
### 5. Template Integrator Agent — Fuse Multiple Patterns Into One
When a question needs multiple cognitive methods (e.g., root cause *and* scenario planning *and* stakeholder analysis), the Template Integrator doesn't just concatenate them. It uses an LLM to **intelligently merge** methodologies from multiple templates into a single unified context — one role, one set of rules, one directive.
```python
from mycontext.intelligence import TemplateIntegratorAgent
integrator = TemplateIntegratorAgent()
result = integrator.suggest_and_integrate(
"Revenue dropped 40% — what happened, what are the scenarios, who's affected?",
provider="openai",
)
ctx = result.to_context()
ctx.execute(provider="openai")
```
### 6. Chain Orchestration Agent — Auto-Build Multi-Step Workflows
Complex questions need multiple reasoning steps. The Chain Orchestration Agent analyzes your question, selects and orders patterns from the full catalog, and generates the `build_context()` parameters for each step — automatically.
```python
from mycontext.intelligence import build_workflow_chain
result = build_workflow_chain(
"Outage last week caused churn spike. What happened, root cause, and recovery plan?",
provider="openai",
)
print(result.chain) # ['temporal_sequence_analyzer', 'root_cause_analyzer', 'future_scenario_planner']
print(result.chain_params) # auto-generated build_context params for each step
```
### 7. Intelligent Pattern Suggestion — Keyword, LLM, or Hybrid
Don't know which pattern fits? `suggest_patterns()` maps your question to the best patterns using keyword matching, LLM reasoning, or both:
```python
from mycontext.intelligence import suggest_patterns
result = suggest_patterns(
"Why did revenue drop? Timeline, root cause, and what to do next.",
mode="hybrid",
llm_provider="openai",
suggest_chain=True,
)
print(result.suggested_chain)
# → ['temporal_sequence_analyzer', 'root_cause_analyzer', 'future_scenario_planner']
print(result.to_markdown())
```
### 8. Auto-Transform Any Question → Perfect Context
One call. No pattern selection needed. The Transformation Engine analyzes your input (type, complexity, domain, key concepts) and builds the right context automatically:
```python
from mycontext.intelligence import transform
ctx = transform("Should we migrate to microservices? Compare tradeoffs.")
# Engine detects: comparison + decision → selects ComparativeAnalyzer
print(ctx.to_markdown())
```
### 9. Blueprint — Multi-Component Context Architecture
For production applications that need more than a single template. Blueprints orchestrate multiple components (guidance, knowledge, reasoning) with **token budget management** and strategy-based optimization (speed / quality / cost / balanced):
```python
from mycontext.structure import Blueprint
from mycontext.foundation import Guidance
blueprint = Blueprint(
name="research_assistant",
guidance=Guidance(role="Expert research analyst"),
directive_template="Research and explain: {topic}",
token_budget=4000,
optimization="balanced",
)
ctx = blueprint.build(topic="Quantum computing advances in 2025")
```
### 10. 13 Export Formats — True Vendor Neutrality
Build once, export everywhere. One context works with every LLM and framework:
```python
ctx.to_openai() # OpenAI Chat API
ctx.to_anthropic() # Claude
ctx.to_google() # Gemini
ctx.to_langchain() # LangChain messages
ctx.to_llamaindex() # LlamaIndex
ctx.to_crewai() # CrewAI
ctx.to_autogen() # AutoGen
ctx.to_yaml() # Portable config
ctx.to_json() # JSON
ctx.to_xml() # XML
ctx.to_markdown() # Human-readable
ctx.to_messages() # Universal message list
ctx.to_dict() # Python dict
```
Plus dedicated integration helpers for **LangChain, LlamaIndex, CrewAI, AutoGen, DSPy, Semantic Kernel, and Google ADK**.
### 11. Agent Skills with Quality Gates
Define reusable skills as SKILL.md files. Fuse them with cognitive patterns. Gate execution on quality — if the generated context scores below threshold, it blocks *before* wasting an API call:
```python
from mycontext.skills import SkillRunner, improvement_report, suggested_edits
runner = SkillRunner()
result = runner.run(
Path("skills/compare_options"),
task="Compare microservices vs monolith",
quality_threshold=0.7,
)
print(f"Quality: {result.quality_score.overall}, Gated: {result.gated}")
# Get concrete improvement suggestions for the skill
print(improvement_report(result))
for edit in suggested_edits(result):
print(f" → {edit}")
```
Skills can declare `pattern: comparative_analyzer` in frontmatter — the runner fuses the skill body with that cognitive pattern automatically.
### 12. Template Benchmarking with CAI
Automated test suites for cognitive templates. Load YAML test cases, run templates through questions, evaluate output quality, and compute CAI scores — in CI or from the CLI:
```bash
python -m mycontext.benchmark_cli run --template diagnostic_root_cause_analyzer
python -m mycontext.benchmark_cli run-all --output results.json
```
---
## At a Glance
| Capability | mycontext-ai | Typical prompt libraries |
|-----------|-------------|------------------------|
| Cognitive patterns | 85 research-backed (16 free + 69 enterprise) | 10-20 generic templates |
| Context quality scoring | 6 dimensions + issues + suggestions | None |
| Output quality scoring | 5 dimensions (separate from prompt quality) | None |
| Template effectiveness proof | CAI (quantitative lift measurement) | None |
| Pattern suggestion | Keyword + LLM + hybrid modes | Manual selection |
| Multi-template fusion | Intelligent merge (not concatenation) | None |
| Workflow chain generation | Auto-select + auto-parameterize | Manual |
| Export formats | 13 (OpenAI, Anthropic, LangChain, YAML, ...) | 1-2 |
| Framework integrations | 7 (LangChain, CrewAI, AutoGen, DSPy, ...) | 0-1 |
| Agent Skills + quality gate | Pattern-fused skills with threshold gating | None |
| Research citations | 150+ peer-reviewed papers | 0-5 |
---
## Quick Start
```bash
pip install mycontext-ai
# Add LLM execution (recommended)
pip install litellm
```
```python
from mycontext import Context, Guidance, Directive
ctx = Context(
guidance=Guidance(
role="Senior security reviewer",
rules=["Flag every injection risk", "Suggest concrete fixes"],
style="concise, actionable",
),
directive=Directive(content="Review this API for auth and input validation."),
)
# Export to any LLM
ctx.to_openai() # → OpenAI messages
ctx.to_anthropic() # → Claude format
ctx.to_langchain() # → LangChain messages
# Or execute directly (requires litellm)
result = ctx.execute(provider="openai")
```
All providers route through LiteLLM, giving you access to 100+ models. You can also register custom providers (e.g., Ollama for local models).
---
## Use Cases
### Chain patterns for complex analysis
Strategic questions need multiple reasoning steps. Chain patterns so each stage feeds the next:
```python
from mycontext.templates.enterprise.temporal import TemporalSequenceAnalyzer
from mycontext.templates.enterprise.diagnostic import RootCauseAnalyzer
from mycontext.templates.enterprise.synthesis import HolisticIntegrator
# Stage 1: Timeline
ctx1 = TemporalSequenceAnalyzer().build_context(
events="Q1: Support tickets doubled. Q2: Competitor launched. Q3: Complaints up 40%.",
time_span="12 months",
)
# Stage 2: Root cause (fed by Stage 1 output)
ctx2 = RootCauseAnalyzer().build_context(
problem="Customer satisfaction collapse",
symptoms=ctx1.directive.content[:2500],
)
# Stage 3: Synthesis
ctx3 = HolisticIntegrator().build_context(
topic="Recovery strategy",
perspectives=f"Timeline: {ctx1.directive.content[:600]}\nRCA: {ctx2.directive.content[:600]}",
)
result = ctx3.execute(provider="openai")
```
### Drop into any orchestrator
mycontext contexts work as tools inside LangChain, CrewAI, smolagents, AutoGen, Semantic Kernel, and Google ADK:
```python
from mycontext.intelligence import transform
from mycontext.integrations import LangChainHelper
ctx = transform("What are the top 3 risks for this launch?")
messages = LangChainHelper.to_messages(ctx)
# → Use in your LangChain chain or agent
```
Integration helpers are available for all 7 frameworks out of the box.
### Enforce structured output
```python
from mycontext.utils.structured_output import output_format
instruction = output_format("json", schema={"summary": "str", "risks": "list", "recommendation": "str"})
ctx = Context(directive=Directive(content=f"Analyze this proposal.\n\n{instruction}"))
```
---
## 85 Cognitive Patterns
### Free Patterns (16)
Included in every install. Production-ready for analysis, decision-making, reasoning, and communication.
| Pattern | What it does |
|---------|-------------|
| **DecisionFramework** | Structured multi-criteria decision analysis |
| **ComparativeAnalyzer** | Side-by-side comparison across dimensions |
| **RootCauseAnalyzer** | Five Whys + fishbone + systematic diagnosis |
| **DataAnalyzer** | Data description → analysis plan → insights |
| **QuestionAnalyzer** | Decompose complex questions into structured inquiry |
| **StepByStepReasoner** | Chain-of-thought with explicit reasoning steps |
| **HypothesisGenerator** | Generate and evaluate competing hypotheses |
| **ScenarioPlanner** | Future scenarios with probability assessment |
| **RiskAssessor** | Risk identification, scoring, and mitigation |
| **Brainstormer** | Structured ideation with divergent/convergent phases |
| **CodeReviewer** | Security, performance, and maintainability review |
| **TechnicalTranslator** | Translate technical content for different audiences |
| **AudienceAdapter** | Adapt message for specific audience and context |
| **SocraticQuestioner** | Guided inquiry through Socratic method |
| **SynthesisBuilder** | Integrate multiple sources into coherent synthesis |
| **StakeholderMapper** | Map stakeholders, interests, and influence |
### Enterprise Patterns (+69)
Advanced patterns for temporal reasoning, diagnostics, systems thinking, ethical analysis, metacognition, learning science, and cross-domain synthesis. **Enterprise patterns require a valid license key** — they are not included in the public PyPI package. Contact us to obtain a license.
```python
import mycontext
mycontext.activate_license("MC-ENT-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
# Enterprise patterns are now unlocked for this session and all future sessions
```
**Categories:** Metacognition · Ethical Reasoning · Systems Thinking · Learning & Knowledge Building · Evaluation & Assessment · Temporal Reasoning · Diagnostic & Troubleshooting · Synthesis & Integration · Advanced Decision · Advanced Problem Solving · Advanced Planning · Advanced Analysis · Advanced Reasoning · Advanced Creative · Advanced Communication · Advanced Specialized
---
## Web Application
mycontext also ships as a full-featured **web application** — a context engineering workbench with a visual pattern library, chain builder, and an AI-powered Context Copilot that guides you through building and refining contexts step by step. The web app is available separately from the SDK.
---
## Installation
```bash
# Core SDK (includes 16 free patterns, intelligence layer, quality metrics)
pip install mycontext-ai
# Add LLM execution support (recommended)
pip install mycontext-ai litellm
# Optional: provider-specific SDKs
pip install "mycontext-ai[openai]" # OpenAI SDK
pip install "mycontext-ai[anthropic]" # Anthropic SDK
pip install "mycontext-ai[google]" # Google GenAI SDK
pip install "mycontext-ai[all]" # All provider SDKs
```
---
## What This Is (and Isn't)
**mycontext-ai is a context engineering library.** It structures and transforms your questions into high-quality prompts using research-backed cognitive patterns. It measures prompt quality *and* output quality. It proves templates work with quantitative metrics. It exports to any LLM format.
**It is not** a prompt template string library. It is not an LLM wrapper. It is not an agent framework. It works *with* your existing agent framework (LangChain, CrewAI, AutoGen, etc.) by giving it better inputs.
The core insight: **the quality of an LLM's output is bounded by the quality of its input.** mycontext engineers that input — and proves it.
---
## License
MIT. Free edition includes 16 patterns and the full intelligence layer. Enterprise edition (+69 advanced patterns) requires a license key.
---
<div align="center">
**The quality of an LLM's output is bounded by the quality of its input.**
[Get Started](#quick-start)
</div>
| text/markdown | null | SadhiraAI <hello@sadhiraai.com> | null | null | MIT | ai, claude, context-engineering, gpt, langchain, langgraph, llm, prompt-engineering, transformation | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"pydantic>=2.11.0",
"pyyaml>=6.0.2",
"anthropic>=0.79.0; extra == \"all\"",
"google-genai>=1.0.0; extra == \"all\"",
"openai>=2.0.0; extra == \"all\"",
"tiktoken>=0.7.0; extra == \"all\"",
"anthropic>=0.79.0; extra == \"anthropic\"",
"black>=24.10.0; extra == \"dev\"",
"ipython>=8.29.0; extra == \"dev\"",
"mypy>=1.13.0; extra == \"dev\"",
"pre-commit>=4.0.0; extra == \"dev\"",
"pytest-asyncio>=0.24.0; extra == \"dev\"",
"pytest-cov>=6.0.0; extra == \"dev\"",
"pytest>=8.3.4; extra == \"dev\"",
"ruff>=0.7.4; extra == \"dev\"",
"mkdocs-material>=9.5.0; extra == \"docs\"",
"mkdocs>=1.6.0; extra == \"docs\"",
"mkdocstrings[python]>=0.26.0; extra == \"docs\"",
"google-genai>=1.0.0; extra == \"google\"",
"openai>=2.0.0; extra == \"openai\"",
"crewai-tools>=0.16.0; extra == \"orchestration\"",
"crewai>=0.76.0; extra == \"orchestration\"",
"langchain-openai>=0.3.0; extra == \"orchestration\"",
"langchain>=0.3.0; extra == \"orchestration\"",
"langgraph>=0.2.0; extra == \"orchestration\"",
"pyautogen>=0.2.0; extra == \"orchestration\"",
"semantic-kernel>=1.0.0; extra == \"orchestration\"",
"tiktoken>=0.7.0; extra == \"tokens\""
] | [] | [] | [] | [
"Homepage, https://github.com/SadhiraAI/mycontext",
"Documentation, https://github.com/SadhiraAI/mycontext#readme",
"Repository, https://github.com/SadhiraAI/mycontext",
"Changelog, https://github.com/SadhiraAI/mycontext/blob/main/CHANGELOG.md",
"Issues, https://github.com/SadhiraAI/mycontext/issues"
] | twine/6.2.0 CPython/3.11.9 | 2026-02-21T04:23:49.329143 | mycontext_ai-0.2.1.tar.gz | 51,903,767 | 40/d6/670127a5a001b57f8a2810031f6b7dd09d5444e7838ed0162dcbf562550f/mycontext_ai-0.2.1.tar.gz | source | sdist | null | false | 4105817c37513da3a77dec6127234ce0 | 225a7581934b421930e67ca7df5d394ed160cfc5417be6024efd1554a2118c57 | 40d6670127a5a001b57f8a2810031f6b7dd09d5444e7838ed0162dcbf562550f | null | [
"LICENSE"
] | 241 |
2.4 | mqttd | 0.5.3 | FastAPI-like MQTT/MQTTS server for Python, compatible with libcurl clients | # MQTTD - FastAPI-like MQTT/MQTTS Server
A high-performance Python package for creating MQTT and MQTTS servers with a FastAPI-like decorator-based API. Fully compatible with libcurl clients and designed for production use.
**Now supports MQTT 5.0** with full backward compatibility for MQTT 3.1.1.
---
## Supported Features (Code-Verified)
The following features are implemented and used in the codebase (`ref-code/mqttd`). This list is derived from line-by-line analysis of `mqttd/app.py`, `mqttd/session.py`, `mqttd/thread_safe.py`, and related modules.
### Core Features
- **FastAPI-like API**: Decorators `@app.subscribe(topic)` and `@app.publish_handler(topic)` for topic subscriptions and PUBLISH handlers
- **MQTT 5.0 Protocol**: Full support with automatic protocol detection (MQTT 3.1.1 vs 5.0)
- **MQTT 3.1.1 Compatibility**: Full backward compatibility
- **MQTTS Support**: TLS/SSL via `ssl_context` (e.g. port 8883)
- **QUIC Transport**: Optional MQTT over QUIC (ngtcp2, pure Python, or aioquic)
- **Async/Await**: Built on asyncio; one task per client connection
- **Configuration File**: `config_file` with options (version, PUBLISH-before-SUBACK, short-PUBLISH, error-CONNACK, excessive-remaining, Testnum)
### Multiple Concurrent Clients
- **Per-connection tasks**: Each TCP or QUIC connection is handled by a dedicated asyncio task (`_handle_client`)
- **Connection state**: `_clients` dict maps socket to `(MQTTClient, StreamWriter)`; connection limits via `max_connections` and `max_connections_per_ip`
- **Session management**: Per ClientID sessions (SessionManager); session takeover and concurrent same-ClientID handling per MQTT 5.0 (Clean Start, Session Present, Session Expiry Interval)
### MQTT 5.0 Features
- **Reason codes**: In CONNACK, SUBACK, UNSUBACK, PUBACK, etc.
- **Properties**: Full encode/decode for property types including User Properties, Message Expiry Interval, Topic Aliases, **Response Topic**, **Correlation Data**, Content Type, Subscription Identifier, Receive Maximum, etc.
- **Session**: Session Expiry Interval, Clean Start, Session Present, session takeover, expired session cleanup
- **Flow control**: Receive Maximum negotiation; in-flight QoS tracking per client
- **Will message**: Last Will and Testament with MQTT 5.0 properties; **Will Delay Interval** supported (delayed send after disconnect)
- **Subscription options**: No Local, Retain As Published, Retain Handling (0/1/2) per subscription
- **Topic aliases**: Server-side alias mapping per session
- **Message expiry**: Message Expiry Interval checked before forwarding
### Routing Modes
- **Direct routing** (default): In-memory routing; topic trie + shared subscription trie for O(m) lookup
- **Redis Pub/Sub** (optional): Publish to Redis channel by topic; subscribe to Redis when MQTT clients subscribe; `_redis_message_listener` forwards Redis messages to MQTT clients
### Redis and MCP Request/Response
- **Redis connection**: Optional `redis_host`/`redis_port`/`redis_url`; `_connect_redis()`, `_disconnect_redis()`, health check reports `redis_connected`
- **Redis Pub/Sub**: Publish on PUBLISH; subscribe per topic; forward Redis messages to subscribed MQTT clients
- **Store until MCP response, then reply to client**: When a client sends a PUBLISH with MQTT 5.0 **Response Topic** (and optionally **Correlation Data**), the server:
- Stores request context in Redis at `mqttd:request:{correlation_id}` with TTL (e.g. 300s)
- Publishes to channel `mqttd:mcp:requests` for MCP workers (payload: correlation_id, topic, payload_b64, response_topic)
- Subscribes to `mqttd:mcp:responses`; when a response message arrives (JSON: correlation_id, payload_b64), looks up the stored request, forwards the reply to `response_topic`, and deletes the request key
### Retained Messages
- **Store/delete**: Retained PUBLISH stored in `_retained_messages`; empty payload with retain clears the topic
- **Delivery on subscribe**: `_deliver_retained_messages` with MQTT 5.0 retain_handling and retain_as_published
### Shared Subscriptions (MQTT 5.0)
- **Syntax**: `$share/group/topic`; round-robin delivery per group via `_shared_trie` and `_shared_group_index`
### Keepalive and Timeouts
- **Keepalive tracking**: `_client_keepalive` stores last_activity, keepalive_seconds, and optional ping task per socket
- **Activity reset**: On any received message (including PINGREQ and PUBLISH), last_activity is updated so timeout is effectively reset when the client is active
- **Keepalive monitor**: Background task disconnects if no activity for 1.5× keepalive interval
- **Read timeout**: `reader.read()` uses keepalive-based timeout (1.5× keepalive) so idle connections are closed
### Rate Limiting
- **Per-client**: `_rate_limits` tracks message count and subscription count per socket
- **Options**: `max_messages_per_second`, `max_subscriptions_per_minute`; `_check_rate_limit()` used on PUBLISH and SUBSCRIBE
### Observability and Admin
- **Metrics**: `get_metrics()` returns total_connections, current_connections, total_messages_published/received, total_subscriptions/unsubscriptions, retained_messages_count, active_subscriptions_count, connections_per_ip
- **Health**: `health_check()` returns status (healthy/degraded), running, connections, max_connections, redis_connected, errors list
- **Graceful shutdown**: `shutdown(timeout)` sets _running, closes server, waits for connections to drain (with timeout)
### Programmatic Publish
- **To all**: Normal PUBLISH routing and optional `app.publish(topic, payload, qos, retain)` when using Redis
- **To one client**: `publish_to_client(client, topic, payload, qos, retain)` sends a PUBLISH to a specific client by client_id
### Thread-Safety and No-GIL
- **Thread-safe structures** (`mqttd/thread_safe.py`): `ThreadSafeDict`, `ThreadSafeSet`, `ThreadSafeTopicTrie`, `ThreadSafeConnectionPool` (RLock-based) for use with Python 3.13+ no-GIL or 3.14t
- **Topic lookup**: `_topic_trie` and `_shared_trie` are ThreadSafeTopicTrie for O(m) subscription matching
### Transport
- **TCP**: `asyncio.start_server(_handle_client, host, port, ssl=...)`; can be disabled with `enable_tcp=False`
- **QUIC**: ngtcp2 (preferred), pure Python, or aioquic; `enable_quic`, `quic_port`, `quic_certfile`, `quic_keyfile`; QUIC-only mode when TCP disabled
---
## Installation
### Basic
```bash
pip install -e .
```
### Requirements
- **Python**: 3.7+ (3.13+ recommended for no-GIL; 3.14t for free-threaded)
- **Redis**: Optional — only for Redis pub/sub and MCP request/response (`pip install redis>=5.0.0` or `pip install -e ".[redis]"`)
### QUIC (ngtcp2 + WolfSSL)
```bash
./scripts/build-server.sh # then pip install -e .
```
See [docs/BUILD_SERVER.md](docs/BUILD_SERVER.md) for details.
---
## Quick Start
### Basic server (direct routing, no Redis)
```python
from mqttd import MQTTApp, MQTTMessage, MQTTClient
app = MQTTApp(port=1883)
@app.subscribe("sensors/temperature")
async def on_subscribe(topic: str, client: MQTTClient):
print(f"Client {client.client_id} subscribed to {topic}")
@app.publish_handler("sensors/+")
async def on_publish(message: MQTTMessage, client: MQTTClient):
print(f"Received {message.topic}: {message.payload_str}")
if __name__ == "__main__":
app.run()
```
### Multiple clients and connection limits
```python
app = MQTTApp(
port=1883,
max_connections=1000,
max_connections_per_ip=50
)
# Each connection gets its own task; sessions are per ClientID
app.run()
```
### Redis Pub/Sub (multi-server)
```python
app = MQTTApp(
port=1883,
redis_host="localhost",
redis_port=6379
)
@app.subscribe("sensors/#")
async def on_sub(topic: str, client: MQTTClient):
print(f"{client.client_id} subscribed to {topic}")
@app.publish_handler("sensors/+")
async def on_pub(message: MQTTMessage, client: MQTTClient):
print(f"PUBLISH {message.topic} (published to Redis)")
app.run()
```
### Redis + MCP request/response (store until agent replies)
Client sends PUBLISH with MQTT 5.0 **Response Topic** and optional **Correlation Data**. Server stores the request in Redis, publishes to `mqttd:mcp:requests`; when an MCP worker publishes a response to `mqttd:mcp:responses`, the server forwards the reply to the client’s response topic.
**Server (with Redis):**
```python
app = MQTTApp(port=1883, redis_host="localhost", redis_port=6379)
@app.subscribe("devices/+/request")
async def on_request_sub(topic: str, client: MQTTClient):
print(f"Client {client.client_id} subscribed to {topic}")
@app.publish_handler("devices/+/request")
async def on_request_pub(message: MQTTMessage, client: MQTTClient):
# Request is auto-stored in Redis (when response_topic is set) and
# published to mqttd:mcp:requests; MCP workers consume and reply
# to mqttd:mcp:responses; server then forwards to response_topic
print(f"Request on {message.topic} from {client.client_id}")
app.run()
```
**MCP worker contract (Redis):**
- Subscribe to Redis channel `mqttd:mcp:requests`. Each message is JSON: `correlation_id`, `topic`, `payload_b64`, `response_topic`.
- After calling your MCP agent, publish to Redis channel `mqttd:mcp:responses` a JSON message: `{"correlation_id": "<id>", "payload_b64": "<base64 reply>"}`.
**Client (MQTT 5.0):** Publish with Response Topic and optional Correlation Data so the server stores the request and later delivers the reply on that topic.
### Metrics and health (e.g. for admin API)
```python
app = MQTTApp(port=1883)
# In another thread or admin endpoint:
metrics = app.get_metrics()
# total_connections, current_connections, total_messages_published,
# retained_messages_count, active_subscriptions_count, connections_per_ip, ...
health = app.health_check()
# status, running, connections, max_connections, redis_connected, errors
```
### MQTTS (TLS)
```python
import ssl
from mqttd import MQTTApp, MQTTClient
ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_ctx.load_cert_chain("server.crt", "server.key")
app = MQTTApp(port=8883, ssl_context=ssl_ctx)
@app.subscribe("secure/topic")
async def on_secure(topic: str, client: MQTTClient):
print(f"Secure client: {client.client_id} -> {topic}")
app.run()
```
### MQTT over QUIC (QUIC-only)
```python
app = MQTTApp(
enable_tcp=False,
enable_quic=True,
quic_port=1884,
quic_certfile="cert.pem",
quic_keyfile="key.pem",
)
@app.subscribe("sensors/#")
async def on_sensor(topic: str, client: MQTTClient):
print(f"[{client.client_id}] Subscribed to {topic}")
app.run()
```
### Shared subscriptions (MQTT 5.0)
Clients subscribe with `$share/groupname/topic`. Server delivers each message to one member of the group (round-robin).
```python
app = MQTTApp(port=1883)
@app.subscribe("$share/workers/commands")
async def on_shared(topic: str, client: MQTTClient):
print(f"Shared sub: {client.client_id} -> {topic}")
app.run()
```
### Configuration file
Create `mqttd.config`:
```
version 5
```
```python
app = MQTTApp(port=1883, config_file="mqttd.config")
app.run()
```
---
## Configuration Options
```python
MQTTApp(
host="0.0.0.0",
port=1883,
ssl_context=None,
config_file=None,
redis_host=None,
redis_port=6379,
redis_db=0,
redis_password=None,
redis_url=None,
use_redis=False,
enable_tcp=True,
enable_quic=False,
quic_port=1884,
quic_certfile=None,
quic_keyfile=None,
max_connections=None,
max_connections_per_ip=None,
max_messages_per_second=None,
max_subscriptions_per_minute=None,
)
```
---
## API Reference (Summary)
- **`@app.subscribe(topic, qos=0)`** — Subscription handler; optional return bytes to send to subscriber.
- **`@app.publish_handler(topic=None)`** — PUBLISH handler; `topic` filter or all if `None`.
- **`app.run(host=None, port=None, ssl_context=None)`** — Blocking run.
- **`app.get_metrics()`** — Dict of server metrics.
- **`app.health_check()`** — Dict with status, running, connections, redis_connected, errors.
- **`app.shutdown(timeout=30.0)`** — Graceful shutdown (async).
- **`app.publish(topic, payload, qos=0, retain=False)`** — Programmatic publish (async; when Redis used).
- **`app.publish_to_client(client, topic, payload, qos=0, retain=False)`** — Send PUBLISH to one client (async).
**Types:** `MQTTMessage` (topic, payload, qos, retain, packet_id, payload_str, payload_json), `MQTTClient` (client_id, username, password, keepalive, clean_session, address).
---
## Architecture (Summary)
- **Multiple clients**: One asyncio task per connection; `_clients` dict; SessionManager per ClientID.
- **Routing**: Direct (in-memory trie) or Redis pub/sub; optional MCP flow via Redis keys/channels.
- **Thread-safety**: ThreadSafeTopicTrie (and related structures in `thread_safe.py`) for no-GIL readiness.
- **Protocols**: CONNECT/CONNACK, PUBLISH, PUBACK/PUBREC/PUBREL/PUBCOMP, SUBSCRIBE/SUBACK, UNSUBSCRIBE/UNSUBACK, PINGREQ/PINGRESP, DISCONNECT.
---
## Examples
See `examples/`:
- `basic_server.py` — Basic MQTT server
- `mqtt5_server.py` — MQTT 5.0
- `secure_server.py` — MQTTS
- `redis_server.py` — Redis pub/sub
- `direct_routing_server.py` — Direct routing
- `mqtt_quic_server.py` / `mqtt_quic_only_server.py` — QUIC
- `config_server.py` — Config file
---
## Testing
```bash
python tests/test_new_features.py
# or
pytest tests/ -v
```
---
## License
MIT License.
## Links
- **Repository**: https://github.com/arusatech/mqttd
- **Author**: Yakub Mohammad (yakub@arusatech.com)
- **Version**: 0.5.0 (see pyproject.toml)
| text/markdown | Yakub Mohammad | yakub@arusatech.com | null | null | MIT | mqtt, mqtts, mqtt5, server, broker, fastapi, libcurl, quic, http3 | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Communications",
"Topic :: Internet",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Networking"
] | [] | https://github.com/arusatech/mqttd | null | >=3.7 | [] | [] | [] | [
"redis>=5.0.0; extra == \"redis\"",
"aioquic>=0.9.20; extra == \"quic\"",
"pytest>=6.0; extra == \"dev\"",
"pytest-asyncio>=0.18.0; extra == \"dev\"",
"black>=21.0; extra == \"dev\"",
"mypy>=0.900; extra == \"dev\"",
"redis>=5.0.0; extra == \"all\"",
"aioquic>=0.9.20; extra == \"all\""
] | [] | [] | [] | [
"Homepage, https://github.com/arusatech/mqttd",
"Repository, https://github.com/arusatech/mqttd",
"Documentation, https://github.com/arusatech/mqttd#readme",
"Bug Tracker, https://github.com/arusatech/mqttd/issues"
] | poetry/2.2.1 CPython/3.12.12 Linux/6.12.0-124.27.1.el10_1.x86_64 | 2026-02-21T04:23:24.552839 | mqttd-0.5.3.tar.gz | 104,351 | 71/58/e033f0e2efbfda1c25cbc880734471037841034126bd4dada35f7134623a/mqttd-0.5.3.tar.gz | source | sdist | null | false | 335044919109e951a8d12fc5deed7801 | 012bf027e935d3b187c8f259d2994902f78a79dcc494fd1f3d9a67b3af81f703 | 7158e033f0e2efbfda1c25cbc880734471037841034126bd4dada35f7134623a | null | [] | 245 |
2.4 | matrx-orm | 1.4.3 | Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching. Works with any PostgreSQL database. | # matrx-orm
**Async-first PostgreSQL ORM** with bidirectional migrations, schema introspection, full relationship support (FK, IFK, M2M), and built-in state caching. Works with any PostgreSQL database — Supabase, AWS RDS, Google Cloud SQL, self-hosted, or Docker.
[](https://pypi.org/project/matrx-orm/)
[](https://www.python.org/)
[](https://opensource.org/licenses/MIT)
---
## Table of Contents
- [Features](#features)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Models and Fields](#models-and-fields)
- [CRUD Operations](#crud-operations)
- [Querying](#querying)
- [Relationships](#relationships)
- [Many-to-Many](#many-to-many)
- [State Caching](#state-caching)
- [Migrations](#migrations)
- [Schema Introspection](#schema-introspection)
- [BaseManager](#basemanager)
- [Error Handling](#error-handling)
- [Testing](#testing)
- [Publishing](#publishing)
- [Version History](#version-history)
---
## Features
| Capability | Detail |
|---|---|
| **Async-first** | Built on `asyncpg` and `psycopg3`; every operation is `async/await` |
| **PostgreSQL-generic** | Zero vendor lock-in; works with any standard PostgreSQL instance |
| **Full field library** | UUID, Char, Text, Integer, Float, Boolean, DateTime, JSON, JSONB, Array, Decimal, Enum, IP, HStore, and more |
| **Relationships** | ForeignKey, InverseForeignKey, ManyToMany (declarative or config-based) |
| **Resilient FK fetch** | `_unfetchable` flag silences errors for FKs pointing to inaccessible tables (e.g., Supabase `auth.users`) |
| **Bidirectional migrations** | Model-first, SQL-first, or hybrid; auto-generate migrations from schema diffs |
| **Schema introspection** | Generate Python models and typed managers from an existing database schema |
| **State caching** | Per-model in-memory cache with configurable TTL policies (permanent, long-term, short-term, instant) |
| **BaseManager** | High-level manager class with built-in CRUD, bulk ops, and relationship helpers |
| **Lookup operators** | `__in`, `__gt`, `__gte`, `__lt`, `__lte`, `__ne`, `__isnull`, `__contains`, `__icontains`, `__startswith`, `__endswith` |
| **Type-safe** | Full type hints throughout; strict mode compatible |
---
## Installation
```bash
pip install matrx-orm
# or with uv (recommended)
uv add matrx-orm
```
**Requirements:** Python 3.10+ and a PostgreSQL database.
---
## Quick Start
### 1. Register a database
```python
from matrx_orm import register_database, DatabaseProjectConfig
register_database(DatabaseProjectConfig(
name="my_project", # internal identifier used in models
host="localhost",
port="5432",
database_name="my_db",
user="postgres",
password="secret",
alias="main", # short alias for connection pooling
))
```
For Supabase, use your **direct connection string** credentials (not the pooler):
```python
register_database(DatabaseProjectConfig(
name="my_project",
host="db.xxxxxxxxxxxx.supabase.co",
port="5432",
database_name="postgres",
user="postgres",
password="your-db-password",
alias="main",
))
```
### 2. Define models
```python
from matrx_orm import Model, UUIDField, CharField, TextField, BooleanField, ForeignKey
class User(Model):
id = UUIDField(primary_key=True)
username = CharField(max_length=100, unique=True)
email = CharField(max_length=255)
bio = TextField(null=True)
is_active = BooleanField(default=True)
_table_name = "user"
_database = "my_project"
class Post(Model):
id = UUIDField(primary_key=True)
title = CharField(max_length=200)
body = TextField(null=True)
author_id = ForeignKey("User", "id")
is_published = BooleanField(default=False)
_table_name = "post"
_database = "my_project"
```
### 3. Use it
```python
from uuid import uuid4
# Create
user = await User.create(id=str(uuid4()), username="alice", email="alice@example.com")
post = await Post.create(id=str(uuid4()), title="Hello World", author_id=user.id)
# Read
alice = await User.get(username="alice")
posts = await Post.filter(author_id=alice.id, is_published=True).all()
# Update
await Post.filter(id=post.id).update(is_published=True)
# Delete
await Post.filter(id=post.id).delete()
```
---
## Models and Fields
### Model class attributes
| Attribute | Type | Description |
|---|---|---|
| `_table_name` | `str` | Database table name (defaults to snake_case of class name) |
| `_database` | `str` | Database project name (must match a registered `DatabaseProjectConfig`) |
| `_db_schema` | `str \| None` | PostgreSQL schema prefix (e.g. `"public"`, `"analytics"`) |
| `_primary_keys` | `list[str]` | Explicit composite PKs (alternative to `primary_key=True` on field) |
| `_unfetchable` | `bool` | Marks the model as a reference-only table that should never be fetched (e.g. `auth.users`) |
| `_cache_policy` | `CachePolicy` | Cache TTL policy: `PERMANENT`, `LONG_TERM`, `SHORT_TERM` (default), `INSTANT` |
| `_cache_timeout` | `int \| None` | Explicit timeout in seconds (overrides policy) |
| `_inverse_foreign_keys` | `dict` | Declare reverse FK relationships |
| `_many_to_many` | `dict` | Declare M2M relationships through existing junction tables |
### Field types
```python
from matrx_orm import (
UUIDField, # db: TEXT or UUID
CharField, # db: VARCHAR(n)
TextField, # db: TEXT
IntegerField, # db: INTEGER
BigIntegerField, # db: BIGINT
SmallIntegerField, # db: SMALLINT
FloatField, # db: FLOAT
DecimalField, # db: NUMERIC(max_digits, decimal_places)
BooleanField, # db: BOOLEAN
DateTimeField, # db: TIMESTAMP
DateField, # db: DATE
TimeField, # db: TIME
JSONField, # db: JSONB
JSONBField, # db: JSONB (alias)
ArrayField, # db: item_type[]
TextArrayField, # db: TEXT[]
IntegerArrayField, # db: INTEGER[]
BooleanArrayField, # db: BOOLEAN[]
UUIDArrayField, # db: TEXT[]
JSONBArrayField, # db: JSONB[]
EnumField, # db: VARCHAR (validates against enum_class or choices)
IPAddressField, # db: INET
IPNetworkField, # db: CIDR
MacAddressField, # db: MACADDR
HStoreField, # db: HSTORE
PointField, # db: POINT
MoneyField, # db: MONEY
BinaryField, # db: BYTEA
TimeDeltaField, # db: INTERVAL
ForeignKey, # db: UUID (stores PK of related model)
)
```
**Common field parameters:**
```python
UUIDField(
primary_key=False, # mark as primary key
null=True, # allow NULL values
unique=False, # add UNIQUE constraint
default=None, # default value or callable
index=False, # create index
)
```
---
## CRUD Operations
### Create
```python
from uuid import uuid4
# Single create
user = await User.create(id=str(uuid4()), username="alice", email="alice@example.com")
# Bulk create
users = await User.bulk_create([
{"id": str(uuid4()), "username": "bob", "email": "bob@example.com"},
{"id": str(uuid4()), "username": "carol", "email": "carol@example.com"},
])
```
### Read
```python
# Get by PK — raises DoesNotExist if not found
user = await User.get(id=user_id)
# Get or None — returns None if not found
user = await User.get_or_none(id=user_id)
# Skip cache for a fresh DB read
user = await User.get(use_cache=False, id=user_id)
```
### Update
```python
# Update matching rows — returns updated row count
count = await User.filter(id=user_id).update(bio="New bio", is_active=True)
# Bulk update (update specific fields on model instances)
for u in users:
u.is_active = False
updated = await User.bulk_update(users, ["is_active"])
```
### Delete
```python
# Delete matching rows — returns deleted row count
count = await User.filter(id=user_id).delete()
# Bulk delete
deleted = await User.bulk_delete(users)
```
---
## Querying
### Filter and lookup operators
```python
# Exact match (default)
await User.filter(username="alice").all()
# Comparison operators
await User.filter(age__gt=18).all()
await User.filter(age__gte=18).all()
await User.filter(age__lt=65).all()
await User.filter(age__lte=65).all()
await User.filter(status__ne="banned").all()
# IN list
await User.filter(id__in=[id1, id2, id3]).all()
# NULL checks
await User.filter(deleted_at__isnull=True).all()
await User.filter(deleted_at__isnull=False).all()
# String matching
await User.filter(username__contains="ali").all() # LIKE %ali%
await User.filter(username__icontains="ali").all() # ILIKE %ali%
await User.filter(username__startswith="al").all() # LIKE al%
await User.filter(username__endswith="ce").all() # LIKE %ce
```
### Chaining
```python
results = (
await User
.filter(is_active=True)
.exclude(role="admin")
.order_by("username")
.limit(20)
.offset(40)
.select("id", "username", "email")
.all()
)
```
### Terminal methods
```python
results = await User.filter(is_active=True).all() # list[User]
one = await User.filter(username="alice").get() # User (raises if 0 or >1)
first = await User.filter(is_active=True).first() # User | None
count = await User.filter(is_active=True).count() # int
exists = await User.filter(username="alice").exists() # bool
```
### Values / values_list
```python
# Returns list of dicts
rows = await User.filter(is_active=True).values("id", "username")
# Returns list of tuples
rows = await User.filter(is_active=True).values_list("id", "username")
# Returns flat list when flat=True and one field
names = await User.filter(is_active=True).values_list("username", flat=True)
```
### Slicing
```python
# Equivalent to .offset(10).limit(20)
page = await User.filter(is_active=True).order_by("username")[10:30].all()
```
---
## Relationships
### Foreign Key (FK)
```python
class Post(Model):
id = UUIDField(primary_key=True)
title = CharField(max_length=200)
author_id = ForeignKey("User", "id") # stores user PK
_table_name = "post"
_database = "my_project"
```
```python
post = await Post.get(id=post_id)
# Fetch the related User
author = await post.fetch_fk("author_id") # returns User | None
# Fetch all FKs at once (resilient — continues on per-FK errors)
fk_results = await post.fetch_fks() # dict[str, Model | None]
```
### Inverse Foreign Key (IFK)
Use `_inverse_foreign_keys` to traverse FK relationships in reverse:
```python
class User(Model):
id = UUIDField(primary_key=True)
username = CharField(max_length=100)
_inverse_foreign_keys = {
"posts": {
"from_model": "Post",
"from_field": "author_id",
"referenced_field": "id",
}
}
_table_name = "user"
_database = "my_project"
```
```python
user = await User.get(id=user_id)
# Fetch all posts written by this user
posts = await user.fetch_ifk("posts") # list[Post]
# Fetch all IFKs at once (resilient)
ifk_results = await user.fetch_ifks() # dict[str, list[Model]]
```
### Unfetchable FKs (auth.users / external tables)
When a FK points to a table outside your schema (e.g., Supabase `auth.users`), mark the model `_unfetchable = True` to prevent query errors and reduce noise:
```python
class Users(Model):
id = UUIDField(primary_key=True)
email = CharField(max_length=255)
_table_name = "users"
_db_schema = "auth"
_unfetchable = True # never query this table; skip gracefully in fetch_fks()
_database = "my_project"
```
When `fetch_fks()` or `fetch_all_related()` encounters a FK pointing to an `_unfetchable` model, it logs a single warning line and continues — no exceptions, no cascading error output.
---
## Many-to-Many
### Config-based M2M (existing junction table)
Use `_many_to_many` when your junction table already exists in the database:
```python
class Post(Model):
id = UUIDField(primary_key=True)
title = CharField(max_length=200)
_many_to_many = {
"tags": {
"junction_table": "post_tag",
"source_column": "post_id",
"target_column": "tag_id",
"target_model": "Tag",
}
}
_table_name = "post"
_database = "my_project"
```
### Declarative M2M (ManyToManyField)
Use `ManyToManyField` when defining models from scratch. The ORM auto-generates the junction table name:
```python
from matrx_orm import ManyToManyField
class Post(Model):
id = UUIDField(primary_key=True)
title = CharField(max_length=200)
tags = ManyToManyField("Tag") # junction table: "post_tag" (sorted names)
_table_name = "post"
_database = "my_project"
# Custom junction table name:
class Recipe(Model):
id = UUIDField(primary_key=True)
name = CharField(max_length=200)
ingredients = ManyToManyField("Ingredient", db_table="recipe_ingredients")
_table_name = "recipe"
_database = "my_project"
```
### M2M operations
```python
post = await Post.get(id=post_id)
# Fetch related Tags (two-query hop: junction → target)
tags = await post.fetch_m2m("tags") # list[Tag]
# Add tags (idempotent — uses ON CONFLICT DO NOTHING)
await post.add_m2m("tags", tag1_id, tag2_id)
# Remove specific tags
await post.remove_m2m("tags", tag3_id)
# Replace all tags at once
await post.set_m2m("tags", [tag1_id, tag2_id, tag4_id])
# Remove all tags
await post.clear_m2m("tags")
# Fetch all M2M relations at once (resilient)
m2m_results = await post.fetch_m2ms() # dict[str, list[Model]]
```
### Fetch everything at once
```python
all_related = await post.fetch_all_related()
# Returns:
# {
# "foreign_keys": {"author_id": <User>},
# "inverse_foreign_keys": {},
# "many_to_many": {"tags": [<Tag>, <Tag>]},
# }
```
---
## State Caching
Every model has a per-process in-memory cache managed by `StateManager`. The cache is populated automatically on reads and invalidated on writes.
### Cache policies
```python
from matrx_orm.state import CachePolicy
class Config(Model):
id = UUIDField(primary_key=True)
value = TextField()
_cache_policy = CachePolicy.PERMANENT # never expires
_table_name = "config"
_database = "my_project"
```
| Policy | TTL |
|---|---|
| `PERMANENT` | Never expires |
| `LONG_TERM` | 4 hours |
| `SHORT_TERM` | 10 minutes (default) |
| `INSTANT` | 1 minute |
```python
# Custom timeout (seconds), overrides policy
class Session(Model):
_cache_timeout = 300 # 5 minutes
```
### Manual cache control
```python
from matrx_orm.state import StateManager
# Force a fresh database read (bypass cache)
user = await User.get(use_cache=False, id=user_id)
# Manually cache a record
await StateManager.cache(User, user)
# Remove a record from cache
await StateManager.remove(User, user)
# Clear the entire cache for a model
await StateManager.clear_cache(User)
# Count cached records
count = await StateManager.count(User)
```
---
## Migrations
The migration system supports three workflows:
| Workflow | Description |
|---|---|
| **Model-first** | Define/change Python models → `makemigrations` diffs against DB → apply |
| **SQL-first** | Write `up()`/`down()` functions manually in Python migration files |
| **Hybrid** | Mix both; migrations always run in declared dependency order |
### CLI commands
```bash
# Generate a migration from model/DB differences
matrx-orm makemigrations --database my_project --dir migrations
# With a custom name
matrx-orm makemigrations --database my_project --dir migrations --name add_posts_table
# Apply all pending migrations
matrx-orm migrate --database my_project --dir migrations
# Roll back the last N migrations (default: 1)
matrx-orm rollback --database my_project --dir migrations --steps 1
# Show migration status (applied / pending)
matrx-orm status --database my_project --dir migrations
# Create a blank migration file for hand-written SQL
matrx-orm create_empty --database my_project --dir migrations --name custom_ddl
```
### Programmatic API
```python
from matrx_orm import makemigrations, migrate, rollback, migration_status
# Generate migration file(s)
path = await makemigrations("my_project", "./migrations")
# Apply pending migrations
applied = await migrate("my_project", "./migrations")
print(f"Applied: {applied}")
# Roll back last migration
rolled_back = await rollback("my_project", "./migrations", steps=1)
```
### Migration file format
```python
"""Create posts table."""
dependencies = ["0001_initial"]
async def up(db):
await db.execute("""
CREATE TABLE post (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
title VARCHAR(200) NOT NULL,
body TEXT,
author_id UUID NOT NULL REFERENCES "user"(id) ON DELETE CASCADE,
is_published BOOLEAN DEFAULT false,
created_at TIMESTAMPTZ DEFAULT now()
)
""")
await db.execute("""
CREATE INDEX idx_post_author ON post (author_id)
""")
async def down(db):
await db.execute("DROP TABLE IF EXISTS post")
```
The `db` parameter provides: `execute(sql, *args)`, `fetch(sql, *args)`, `fetch_one(sql, *args)`, `fetch_val(sql, *args)`, `execute_many(statements)`.
### State tracking
Matrx-orm maintains a `_matrx_migrations` table in your database:
```sql
CREATE TABLE _matrx_migrations (
id SERIAL PRIMARY KEY,
name VARCHAR(255) NOT NULL UNIQUE,
applied_at TIMESTAMPTZ NOT NULL DEFAULT now(),
checksum VARCHAR(64) NOT NULL
);
```
The checksum detects if a migration file was modified after being applied, alerting you before the next run.
See [MIGRATIONS.md](MIGRATIONS.md) for full documentation.
---
## Schema Introspection
If you already have a database, use the schema builder to generate typed Python models and managers:
```python
from matrx_orm.schema_builder.generator import run_generate_models
await run_generate_models(
database_project="my_project",
output_dir="./database/main",
)
```
This introspects your database and emits:
- `models.py` — typed `Model` subclasses with all fields
- One manager file per table — `BaseManager` subclasses with CRUD methods
- `_many_to_many` configs auto-detected from junction tables
- `_inverse_foreign_keys` configs auto-detected from FK references
After running migrations, run it again to keep models in sync:
```python
from matrx_orm import migrate_and_rebuild
# Apply pending migrations, then regenerate models
await migrate_and_rebuild("my_project", "./migrations", output_dir="./database/main")
```
---
## BaseManager
`BaseManager` is a high-level manager class with a full suite of methods. Subclass it to add business logic:
```python
from matrx_orm import BaseManager
class PostManager(BaseManager):
model = Post
async def get_published(self):
return await self.load_items(is_published=True)
async def publish(self, post_id):
await self.update_item(post_id, is_published=True)
```
### Built-in methods
```python
manager = PostManager()
# Basic CRUD
item = await manager.load_by_id(post_id)
items = await manager.load_all()
items = await manager.load_items(is_published=True)
items = await manager.load_items_by_ids([id1, id2, id3])
item = await manager.create_item(id=str(uuid4()), title="Hello")
item = await manager.update_item(post_id, title="Updated")
count = await manager.delete_item(post_id)
# With relationships
item, related = await manager.get_item_with_all_related(post_id)
# related = {"foreign_keys": {...}, "inverse_foreign_keys": {...}, "many_to_many": {...}}
# M2M convenience
item, tags = await manager.get_item_with_m2m(post_id, "tags")
await manager.add_m2m(post_id, "tags", tag1_id, tag2_id)
await manager.remove_m2m(post_id, "tags", tag3_id)
await manager.set_m2m(post_id, "tags", [tag1_id, tag2_id])
await manager.clear_m2m(post_id, "tags")
```
---
## Error Handling
All ORM errors inherit from `ORMException` and carry structured context (model name, query, parameters, operation):
```
================================================================================
[ERROR in Post: QueryExecutor.all()]
Message: Unexpected database error during execute_query: ...
Context:
query: SELECT * FROM post WHERE author_id = $1
params: ['4cf62e4e-...']
filters: {'author_id': '4cf62e4e-...'}
================================================================================
```
### Exception hierarchy
```
ORMException
├── ValidationError — field/model validation failed
├── FieldError — field-level processing error
├── QueryError — query construction or execution error
│ ├── DoesNotExist — zero results when one was expected
│ └── MultipleObjectsReturned
├── DatabaseError — database-level errors
│ ├── ConnectionError
│ ├── IntegrityError — constraint violations
│ └── TransactionError
├── ConfigurationError — missing/invalid ORM config
├── CacheError — state manager failures
├── StateError — state management errors
├── RelationshipError — FK/M2M resolution errors
├── MigrationError — migration apply/rollback failures
├── ParameterError — malformed query parameters
└── UnknownDatabaseError — unexpected database errors with full context
```
### Exception enrichment
Exceptions carry context accumulated as they bubble up through layers — no guessing what caused the error:
```python
from matrx_orm.exceptions import DoesNotExist
try:
post = await Post.get(id=post_id)
except DoesNotExist as e:
print(e.model) # "Post"
print(e.details) # {"filters": {"id": "..."}}
```
---
## Testing
Tests are split into two levels:
### Level 1 — No database required
```bash
pytest -m level1
```
Covers: fields, model meta, model instances, registry, query builder, SQL generation, DDL generator, migration loader, type normalization, exceptions, relations, config, and cache — 361 tests total.
### Level 2 — Live database
```bash
# Set credentials
export MATRX_TEST_DB_HOST=localhost
export MATRX_TEST_DB_PORT=5432
export MATRX_TEST_DB_NAME=matrx_test
export MATRX_TEST_DB_USER=postgres
export MATRX_TEST_DB_PASSWORD=postgres
pytest -m level2
```
Covers: real CRUD, bulk ops, query execution, FK/IFK fetching, M2M operations, cache integration, live migrations, schema diff, and manager methods — 66 tests total.
---
## Publishing
Releases are triggered by a version tag. To cut a new release:
1. Update `version` in `pyproject.toml`
2. Commit all changes
3. Create and push a tag matching the version:
```bash
git add -A
git commit -m "chore: release v1.4.2"
git tag v1.4.2
git push origin main --tags
```
4. GitHub Actions builds the wheel and publishes to PyPI automatically.
The tag **must** match the version in `pyproject.toml` exactly.
---
## Version History
| Version | Highlights |
|---|---|
| **v1.4.3** | Fix `ResourceWarning: unclosed connection` on all sync wrapper methods by closing asyncpg pools before the event loop shuts down |
| **v1.4.2** | Bug fixes: `bulk_create` key error, `ValidationError` API, `IntegrityError` call pattern |
| **v1.4.1** | Fix bulk create and improve error reporting |
| **v1.4.0** | Full PostgreSQL migration system (makemigrations, migrate, rollback, status, DDL generator, schema diff) |
| **v1.3.x** | Many-to-many relationship support (fetch, add, remove, set, clear); resilient FK fetching; improved error context |
| **v1.2.0** | Upgraded to psycopg3 |
| **v1.0.x** | Initial releases |
---
## License
MIT — see [LICENSE](LICENSE) for details.
| text/markdown | null | Matrx <admin@aimatrx.com> | null | Matrx <admin@aimatrx.com> | MIT | async, asyncio, asyncpg, database, many-to-many, migrations, orm, postgresql, schema-builder, supabase | [
"Development Status :: 4 - Beta",
"Framework :: AsyncIO",
"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",
"Programming Language :: Python :: 3.13",
"Topic :: Database",
"Topic :: Database :: Front-Ends",
"Topic :: Software Development :: Libraries :: Python Modules",
"Typing :: Typed"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"asyncpg>=0.30.0",
"gitpython>=3.1.40",
"matrx-utils>=1.0.4",
"psycopg-pool>=3.2.5",
"psycopg[binary]>=3.2.5",
"pytest-asyncio>=1.0; extra == \"dev\"",
"pytest>=9.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/armanisadeghi/matrx-orm",
"Repository, https://github.com/armanisadeghi/matrx-orm",
"Documentation, https://github.com/armanisadeghi/matrx-orm#readme",
"Bug Tracker, https://github.com/armanisadeghi/matrx-orm/issues",
"Changelog, https://github.com/armanisadeghi/matrx-orm/releases"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:22:20.626849 | matrx_orm-1.4.3.tar.gz | 193,580 | b1/42/f1f824440d293a918899d0ccdf5c363b405add730662e3bce9128e1750fa/matrx_orm-1.4.3.tar.gz | source | sdist | null | false | 1a3a32d6d63d4ef9a413dd24341f2619 | 9e3ac526c3258338e715b29b13bf478d352881f3e7e3ebb2480e8a8a254d3c1a | b142f1f824440d293a918899d0ccdf5c363b405add730662e3bce9128e1750fa | null | [] | 239 |
2.4 | pulumi-gitlab | 9.9.0 | A Pulumi package for creating and managing GitLab resources. | [](https://github.com/pulumi/pulumi-gitlab/actions)
[](https://slack.pulumi.com)
[](https://www.npmjs.com/package/@pulumi/gitlab)
[](https://pypi.org/project/pulumi-gitlab)
[](https://badge.fury.io/nu/pulumi.gitlab)
[](https://pkg.go.dev/github.com/pulumi/pulumi-gitlab/sdk/v6/go)
[](https://github.com/pulumi/pulumi-gitlab/blob/master/LICENSE)
# GitLab provider
The GitLab resource provider for Pulumi lets you use GitLab resources in your cloud programs. To use
this package, please [install the Pulumi CLI first](https://pulumi.io/).
## Installing
This package is available in many languages in the standard packaging formats.
### Node.js (Java/TypeScript)
To use from JavaScript or TypeScript in Node.js, install using either `npm`:
$ npm install @pulumi/gitlab
or `yarn`:
$ yarn add @pulumi/gitlab
### Python
To use from Python, install using `pip`:
$ pip install pulumi_gitlab
### Go
To use from Go, use `go get` to grab the latest version of the library
$ go get github.com/pulumi/pulumi-gitlab/sdk/v7
### .NET
To use from .NET, install using `dotnet add package`:
$ dotnet add package Pulumi.Gitlab
## Concepts
The `@pulumi/gitlab` package provides a strongly-typed means to create cloud applications that create and interact
closely with GitLab resources.
## Configuration
The following configuration points are available:
* token (Optional) - This is the GitLab personal access token. It must be provided but can also be sourced via `GITLAB_TOKEN`.
* baseUrl (Optional) - This is the target GitLab base API endpoint. Providing a value is a requirement when working with GitLab CE or GitLab Enterprise e.g. https://my.gitlab.server/api/v4/. It is optional to provide this value and it can also be sourced from the GITLAB_BASE_URL environment variable. The value must end with a slash.
* cacertFile (Optional) - This is a file containing the ca cert to verify the gitlab instance. This is available for use when working with GitLab CE or Gitlab Enterprise with a locally-issued or self-signed certificate chain.
* insecure (Optional) - When set to true this disables SSL verification of the connection to the GitLab instance. Defaults to `false`.
## Reference
For further information, please visit [the GitLab provider docs](https://www.pulumi.com/docs/intro/cloud-providers/gitlab) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/gitlab).
| text/markdown | null | null | null | null | Apache-2.0 | pulumi, gitlab | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"parver>=0.2.1",
"pulumi<4.0.0,>=3.165.0",
"semver>=2.8.1",
"typing-extensions<5,>=4.11; python_version < \"3.11\""
] | [] | [] | [] | [
"Homepage, https://pulumi.io",
"Repository, https://github.com/pulumi/pulumi-gitlab"
] | twine/6.2.0 CPython/3.11.8 | 2026-02-21T04:22:09.109301 | pulumi_gitlab-9.9.0.tar.gz | 594,364 | eb/2b/cccdd447906e48b61159ffa366986ed115c2541badcdf91bbea6529003b3/pulumi_gitlab-9.9.0.tar.gz | source | sdist | null | false | 16e940aa179730cc9213b169d0fac482 | c9a940eb113e041d3e970a487d5d2183f834914b6a500808ef2f258cd0ad45b9 | eb2bcccdd447906e48b61159ffa366986ed115c2541badcdf91bbea6529003b3 | null | [] | 262 |
2.4 | parakeet-mlx | 0.5.1 | An implementation of the Nvidia's Parakeet models for Apple Silicon using MLX. | # Parakeet MLX
An implementation of the Parakeet models - Nvidia's ASR(Automatic Speech Recognition) models - for Apple Silicon using MLX.
## Installation
> [!NOTE]
> Make sure you have `ffmpeg` installed on your system first, otherwise CLI won't work properly.
Using [uv](https://docs.astral.sh/uv/) - recommended way:
```bash
uv add parakeet-mlx -U
```
Or, for the CLI:
```bash
uv tool install parakeet-mlx -U
```
Using pip:
```bash
pip install parakeet-mlx -U
```
## CLI Quick Start
```bash
parakeet-mlx <audio_files> [OPTIONS]
```
## Arguments
- `audio_files`: One or more audio files to transcribe (WAV, MP3, etc.)
## Options
- `--model` (default: `mlx-community/parakeet-tdt-0.6b-v3`, env: `PARAKEET_MODEL`)
- Hugging Face repository of the model to use
- https://huggingface.co/collections/mlx-community/parakeet
- `--output-dir` (default: current directory)
- Directory to save transcription outputs
- `--output-format` (default: srt, env: `PARAKEET_OUTPUT_FORMAT`)
- Output format (txt/srt/vtt/json/all)
- `--output-template` (default: `{filename}`, env: `PARAKEET_OUTPUT_TEMPLATE`)
- Template for output filenames, `{parent}`, `{filename}`, `{index}`, `{date}` is supported.
- `--highlight-words` (default: False)
- Enable word-level timestamps in SRT/VTT outputs
- `--verbose` / `-v` (default: False)
- Print detailed progress information
- `--decoding` (default: `greedy`, env: `PARAKEET_DECODING`)
- Decoding method to use (`greedy` or `beam`)
- `beam` is only available at TDT models for now
- `--chunk-duration` (default: 120 seconds, env: `PARAKEET_CHUNK_DURATION`)
- Chunking duration in seconds for long audio, `0` to disable chunking
- `--overlap-duration` (default: 15 seconds, env: `PARAKEET_OVERLAP_DURATION`)
- Overlap duration in seconds if using chunking
- `--beam-size` (default: 5, env: `PARAKEET_BEAM_SIZE`)
- Beam size (only used while beam decoding)
- `--length-penalty` (default: 0.013, env: `PARAKEET_LENGTH_PENALTY`)
- Length penalty in beam. 0.0 to disable (only used while beam decoding)
- `--patience` (default: 3.5, env: `PARAKEET_PATIENCE`)
- Patience in beam. 1.0 to disable (only used while beam decoding)
- `--duration-reward` (default: 0.67, env: `PARAKEET_DURATION_REWARD`)
- From 0.0 to 1.0, < 0.5 to favor token logprobs more, > 0.5 to favor duration logprobs more. (only used while beam decoding in TDT)
- `--max-words` (default: None, env: `PARAKEET_MAX_WORDS`)
- Max words per sentence
- `--silence-gap` (default: None, env: `PARAKEET_SILENCE_GAP`)
- Split sentence if it exceeds silence gap provided (seconds)
- `--max-duration` (default: None, env: `PARAKEET_MAX_DURATION`)
- Max sentence duration (seconds)
- `--fp32` / `--bf16` (default: `bf16`, env: `PARAKEET_FP32` - boolean)
- Determine the precision to use
- `--full-attention` / `--local-attention` (default: `full-attention`, env: `PARAKEET_LOCAL_ATTENTION` - boolean)
- Use full attention or local attention (Local attention reduces intermediate memory usage)
- Expected usage case is for long audio transcribing without chunking
- `--local-attention-context-size` (default: 256, env: `PARAKEET_LOCAL_ATTENTION_CTX`)
- Local attention context size(window) in frames of Parakeet model
- `--cache-dir` (default: None, env: `PARAKEET_CACHE_DIR`)
- Directory for HuggingFace model cache. If not specified, uses HF's default cache location [(~/.cache/huggingface or values you set in `HF_HOME` or `HF_HUB_CACHE` which is essentially `$HF_HOME/hub`)](https://huggingface.co/docs/huggingface_hub/guides/manage-cache)
## Examples
```bash
# Basic transcription
parakeet-mlx audio.mp3
# Multiple files with word-level timestamps of VTT subtitle
parakeet-mlx *.mp3 --output-format vtt --highlight-words
# Generate all output formats
parakeet-mlx audio.mp3 --output-format all
```
## Python API Quick Start
Transcribe a file:
```py
from parakeet_mlx import from_pretrained
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
result = model.transcribe("audio_file.wav")
print(result.text)
```
Check timestamps:
```py
from parakeet_mlx import from_pretrained
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
result = model.transcribe("audio_file.wav")
print(result.sentences)
# [AlignedSentence(text="Hello World.", start=1.01, end=2.04, duration=1.03, tokens=[...])]
```
Do chunking:
```py
from parakeet_mlx import from_pretrained
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
result = model.transcribe("audio_file.wav", chunk_duration=60 * 2.0, overlap_duration=15.0)
print(result.sentences)
```
Do beam decoding:
```py
from parakeet_mlx import from_pretrained, DecodingConfig, Beam
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
config = DecodingConfig(
decoding = decoding(
beam_size=5, length_penalty=0.013, patience=3.5, duration_reward=0.67
# Refer to CLI options for each parameters
)
)
result = model.transcribe("audio_file.wav", decoding_config=config)
print(result.sentences)
```
Use local attention:
```py
from parakeet_mlx import from_pretrained
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
model.encoder.set_attention_model(
"rel_pos_local_attn", # Follows NeMo's naming convention
(256, 256),
)
result = model.transcribe("audio_file.wav")
print(result.sentences)
```
Specifiy the sentence split options:
```py
from parakeet_mlx import from_pretrained, DecodingConfig, SentenceConfig
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
config = DecodingConfig(
sentence = SentenceConfig(
# Refer to CLI Options to see what those options does
max_words=30, silence_gap=5.0, max_duration=40.0
)
)
result = model.transcribe("audio_file.wav", decoding_config=config)
print(result.sentences)
```
## from_pretrained
Using `from_pretrained` downloads a model from Hugging Face and stores the downloaded model in HF's [cache folder](https://huggingface.co/docs/huggingface_hub/en/guides/manage-cache). You can specify the cache folder by passing it `cache_dir` args. It can return one of those Parakeet variants such as: `ParakeetTDT`, `ParakeetRNNT`, `ParakeetCTC`, or `ParakeetTDTCTC`. For general use cases, the `BaseParakeet` abstraction often suffices. However, if you want to call variant-specific functions like `.decode()` and want linters not to complain, `typing.cast` can be used.
## Timestamp Result
- `AlignedResult`: Top-level result containing the full text and sentences
- `text`: Full transcribed text
- `sentences`: List of `AlignedSentence`
- `AlignedSentence`: Sentence-level alignments with start/end times
- `text`: Sentence text
- `start`: Start time in seconds
- `end`: End time in seconds
- `duration`: Between `start` and `end`.
- `tokens`: List of `AlignedToken`
- `AlignedToken`: Word/token-level alignments with precise timestamps
- `text`: Token text
- `start`: Start time in seconds
- `end`: End time in seconds
- `duration`: Between `start` and `end`.
## Streaming Transcription
For real-time transcription, use the `transcribe_stream` method which creates a streaming context:
```py
from parakeet_mlx import from_pretrained
from parakeet_mlx.audio import load_audio
import numpy as np
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
# Create a streaming context
with model.transcribe_stream(
context_size=(256, 256), # (left_context, right_context) frames
) as transcriber:
# Simulate real-time audio chunks
audio_data = load_audio("audio_file.wav", model.preprocessor_config.sample_rate)
chunk_size = model.preprocessor_config.sample_rate # 1 second chunks
for i in range(0, len(audio_data), chunk_size):
chunk = audio_data[i:i+chunk_size]
transcriber.add_audio(chunk)
# Access current transcription
result = transcriber.result
print(f"Current text: {result.text}")
# Access finalized and draft tokens
# transcriber.finalized_tokens
# transcriber.draft_tokens
```
### Streaming Parameters
- `context_size`: Tuple of (left_context, right_context) for attention windows
- Controls how many frames the model looks at before and after current position
- Default: (256, 256)
- `depth`: Number of encoder layers that preserve exact computation across chunks
- Controls how many layers maintain exact equivalence with non-streaming forward pass
- depth=1: Only first encoder layer matches non-streaming computation exactly
- depth=2: First two layers match exactly, and so on
- depth=N (total layers): Full equivalence to non-streaming forward pass
- Higher depth means more computational consistency with non-streaming mode
- Default: 1
- `keep_original_attention`: Whether to keep original attention mechanism
- False: Switches to local attention for streaming (recommended)
- True: Keeps original attention (less suitable for streaming)
- Default: False
## Low-Level API
To transcribe log-mel spectrum directly, you can do the following:
```python
import mlx.core as mx
from parakeet_mlx.audio import get_logmel, load_audio
from parakeet_mlx import DecodingConfig
# Load and preprocess audio manually
audio = load_audio("audio.wav", model.preprocessor_config.sample_rate)
mel = get_logmel(audio, model.preprocessor_config)
# Generate transcription with alignments
# Accepts both [batch, sequence, feat] and [sequence, feat]
# `alignments` is list of AlignedResult. (no matter if you fed batch dimension or not!)
alignments = model.generate(mel, decoding_config=DecodingConfig())
```
## Todo
- [X] Add CLI for better usability
- [X] Add support for other Parakeet variants
- [X] Streaming input (real-time transcription with `transcribe_stream`)
- [ ] Option to enhance chosen words' accuracy
- [ ] Chunking with continuous context (partially achieved with streaming)
## Acknowledgments
- Thanks to [Nvidia](https://www.nvidia.com/) for training these awesome models and writing cool papers and providing nice implementation.
- Thanks to [MLX](https://github.com/ml-explore/mlx) project for providing the framework that made this implementation possible.
- Thanks to [audiofile](https://github.com/audeering/audiofile) and [audresample](https://github.com/audeering/audresample), [numpy](https://numpy.org), [librosa](https://librosa.org) for audio processing.
- Thanks to [dacite](https://github.com/konradhalas/dacite) for config management.
## License
Apache 2.0
| text/markdown | null | null | null | null | null | mlx, parakeet, asr, nvidia, apple, speech, recognition, ml | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"dacite>=1.9.2",
"huggingface-hub>=0.30.2",
"librosa>=0.11.0",
"mlx>=0.22.1",
"numpy>=2.2.5",
"typer>=0.15.3"
] | [] | [] | [] | [
"Repository, https://github.com/senstella/parakeet-mlx.git",
"Issues, https://github.com/senstella/parakeet-mlx/issues"
] | uv/0.9.13 {"installer":{"name":"uv","version":"0.9.13"},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"macOS","version":null,"id":null,"libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null} | 2026-02-21T04:18:21.203076 | parakeet_mlx-0.5.1.tar.gz | 37,647 | 53/15/78fca046f4526f757fc501d5665463f1157b0dcd9e28d10facdcd50ee12c/parakeet_mlx-0.5.1.tar.gz | source | sdist | null | false | fde58d1b804169dc3901d3df6262f93c | 9d6b2ba328e03e0a4e43bdba0b401201ae832fbbed57fa4c7e2dc2bead517ca2 | 531578fca046f4526f757fc501d5665463f1157b0dcd9e28d10facdcd50ee12c | Apache-2.0 | [
"LICENSE"
] | 407 |
2.4 | fh-saas | 0.9.12 | Production-ready multi-tenant SaaS toolkit for FastHTML applications with authentication, billing, and integrations | # 🚀 fh-saas
<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
## ⚡ Quick Start
### 1. Install
``` bash
pip install fh-saas
```
### 2. Configure Environment
``` bash
# .env file
DB_TYPE=POSTGRESQL
DB_USER=postgres
DB_PASS=your_password
DB_HOST=localhost
DB_NAME=app_host
# Optional integrations
STRIPE_SECRET_KEY=sk_...
STRIPE_WEBHOOK_SECRET=whsec_...
STRIPE_MONTHLY_PRICE_ID=price_...
STRIPE_YEARLY_PRICE_ID=price_...
STRIPE_BASE_URL=https://yourapp.com
RESEND_API_KEY=re_...
GOOGLE_CLIENT_ID=...
GOOGLE_CLIENT_SECRET=...
```
### 3. Initialize Your App
``` python
from fh_saas.db_host import HostDatabase, GlobalUser, TenantCatalog, Membership, gen_id, timestamp
from fh_saas.db_tenant import get_or_create_tenant_db
from fh_saas.utils_db import register_tables, create_indexes
from fh_saas.utils_log import configure_logging
# Configure logging (once at startup)
configure_logging()
# Connect to host database
host_db = HostDatabase.from_env()
# Create a new user
user = GlobalUser(
id=gen_id(),
email="founder@startup.com",
oauth_id="google_abc123",
created_at=timestamp()
)
host_db.global_users.insert(user)
# Create a tenant for their organization
tenant = TenantCatalog(
id=gen_id(),
name="Acme Corp",
db_url="postgresql://...",
created_at=timestamp()
)
host_db.tenant_catalogs.insert(tenant)
# Link user to tenant as owner
membership = Membership(
id=gen_id(),
user_id=user.id,
tenant_id=tenant.id,
profile_id=gen_id(),
role="owner",
created_at=timestamp()
)
host_db.memberships.insert(membership)
host_db.commit()
```
### 4. Work with Tenant Data
``` python
# Get tenant's isolated database
tenant_db = get_or_create_tenant_db(tenant.id, tenant.name)
# Define your app's data models
class Project:
id: str
name: str
status: str = "active"
created_at: str
class Task:
id: str
project_id: str
title: str
completed: bool = False
# Register tables (creates if not exist)
tables = register_tables(tenant_db, [
(Project, "projects", "id"),
(Task, "tasks", "id"),
])
# Add indexes for performance
create_indexes(tenant_db, [
("tasks", ["project_id"], False, None),
("tasks", ["completed"], False, None),
])
# Use the tables
projects = tables["projects"]
projects.insert(Project(id=gen_id(), name="Launch MVP", created_at=timestamp()))
tenant_db.conn.commit()
```
------------------------------------------------------------------------
## 📚 Documentation Guide
| | |
|----|----|
| Section | What You'll Learn |
| **📦 Core** | |
| [Multi-Tenant Setup](https://abhisheksreesaila.github.io/fh-saas/db_host.html) | Host database, user management, tenant registry |
| [Tenant Databases](https://abhisheksreesaila.github.io/fh-saas/db_tenant.html) | Isolated databases per tenant, connection pooling |
| [Table Management](https://abhisheksreesaila.github.io/fh-saas/utils_db.html) | Create tables & indexes from dataclasses |
| **🔌 Integrations** | |
| [HTTP Client](https://abhisheksreesaila.github.io/fh-saas/utils_api.html) | REST APIs with retries, rate limiting, auth |
| [GraphQL Client](https://abhisheksreesaila.github.io/fh-saas/utils_graphql.html) | Streaming pagination for large datasets |
| [Webhooks](https://abhisheksreesaila.github.io/fh-saas/utils_webhook.html) | Receive & verify external webhooks |
| **💳 Payments & Migrations** | |
| [Stripe Payments](https://abhisheksreesaila.github.io/fh-saas/utils_stripe.html) | Subscriptions, trials, access control |
| [DB Migrations](https://abhisheksreesaila.github.io/fh-saas/utils_migrate.html) | Version tracking, rollback support |
| **⚙️ Data Pipeline** | |
| [Background Tasks](https://abhisheksreesaila.github.io/fh-saas/utils_bgtsk.html) | Async job execution |
| [Data Transforms](https://abhisheksreesaila.github.io/fh-saas/utils_polars_mapper.html) | JSON → Polars → Database pipeline |
| **🛠️ Utilities** | |
| [SQL Helpers](https://abhisheksreesaila.github.io/fh-saas/utils_sql.html) | Database type detection, query builders |
| [Logging](https://abhisheksreesaila.github.io/fh-saas/utils_log.html) | Configurable logging for all modules |
| [Authentication](https://abhisheksreesaila.github.io/fh-saas/utils_oauth.html) | OAuth flows (Google, GitHub) |
| [Email Sending](https://abhisheksreesaila.github.io/fh-saas/utils_email.html) | Transactional emails via Resend |
| **📣 Content** | |
| [Blog Publishing](https://abhisheksreesaila.github.io/fh-saas/utils_blog.html) | Markdown blog with frontmatter |
| [SEO & Sitemaps](https://abhisheksreesaila.github.io/fh-saas/utils_seo.html) | Sitemap generation, meta tags |
| [Workflow Engine](https://abhisheksreesaila.github.io/fh-saas/utils_workflow.html) | Multi-step automation |
------------------------------------------------------------------------
## 🛠️ Developer Guide
This project uses [nbdev](https://nbdev.fast.ai/) for literate
programming. The source of truth is in the `nbs/` notebooks.
### Development Setup
``` bash
# Clone and install in dev mode
git clone https://github.com/abhisheksreesaila/fh-saas.git
cd fh-saas
pip install -e .
# Make changes in nbs/ directory, then compile
nbdev_prepare
```
------------------------------------------------------------------------
## 📦 Installation
``` bash
# From PyPI (recommended)
pip install fh-saas
# From GitHub (latest)
pip install git+https://github.com/abhisheksreesaila/fh-saas.git
```
[GitHub](https://github.com/abhisheksreesaila/fh-saas) ·
[PyPI](https://pypi.org/project/fh-saas/) ·
[Documentation](https://abhisheksreesaila.github.io/fh-saas/)
**🤖 For AI Assistants:** [Download
llms-ctx.txt](https://raw.githubusercontent.com/abhisheksreesaila/fh-saas/main/llms-ctx.txt)
— Complete API documentation for LLMs
------------------------------------------------------------------------
## 🤖 AI Assistant Context
**For AI coding assistants** (GitHub Copilot, Claude, ChatGPT, Cursor,
etc.), download the complete API documentation:
**[📥 Download
llms-ctx.txt](https://raw.githubusercontent.com/abhisheksreesaila/fh-saas/main/llms-ctx.txt)**
— Complete fh-saas documentation in LLM-friendly format
### How to use:
1. Download the context file
2. Add to your AI assistant’s instructions/knowledge base
3. Get accurate code suggestions for fh-saas APIs
This file contains all module documentation, examples, and API
signatures formatted for optimal LLM understanding.
------------------------------------------------------------------------
## 🤝 Contributing
Contributions are welcome! Please check the [GitHub
repository](https://github.com/abhisheksreesaila/fh-saas) for issues and
discussions.
| text/markdown | abhishek sreesaila | abhishek sreesaila <abhishek.sreesaila@gmail.com> | null | null | Apache-2.0 | nbdev, jupyter, notebook, python, fasthtml, saas, multi-tenant, oauth, authentication | [
"Natural Language :: English",
"Intended Audience :: Developers",
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only"
] | [] | https://github.com/abhisheksreesaila/fh-saas | null | >=3.9 | [] | [] | [] | [
"httpx>=0.25.0",
"tenacity>=8.2.0",
"polars>=0.20.0",
"Markdown>=3.4.0",
"python-frontmatter>=1.1.0",
"pygments>=2.17.0",
"fastsql",
"python-fasthtml",
"starlette",
"python-dotenv",
"sqlalchemy",
"fastcore",
"stripe",
"faststripe<2026.1.28"
] | [] | [] | [] | [
"Repository, https://github.com/abhisheksreesaila/fh-saas",
"Documentation, https://abhisheksreesaila.github.io/fh-saas"
] | twine/6.2.0 CPython/3.13.5 | 2026-02-21T04:18:07.150307 | fh_saas-0.9.12.tar.gz | 61,677 | c2/3a/94a27feeba3e750815d0d5589ff52f5fda22ca3a9b4de088108e56115d47/fh_saas-0.9.12.tar.gz | source | sdist | null | false | 07015f90bdbae7b550e7189e27a035e8 | 9ca395734fdf7491288a493076c001a0eca4c6314eebcd81b935cc8a46848a74 | c23a94a27feeba3e750815d0d5589ff52f5fda22ca3a9b4de088108e56115d47 | null | [
"LICENSE"
] | 261 |
2.1 | agentmesh-sdk | 0.1.5 | An open-source multi-agent framework for building agent teams with LLMs | <p align="center"><img src= "https://github.com/user-attachments/assets/33d7a875-f64d-422f-8b51-68fb420c81e2" alt="AgentMesh" width="450" /></p>
English | <a href="/docs/README-CN.md">中文</a>
AgentMesh is a **Multi-Agent platform** for AI agents building, providing a framework for inter-agent communication,
task planning, and autonomous decision-making. Build your agent team quickly and solve complex tasks through agent
collaboration.
## Overview
AgentMesh uses a modular layered design for flexible and extensible multi-agent systems:
<img width="700" alt="agentmesh-architecture-diagram" src="https://github.com/user-attachments/assets/81c78d9f-876b-43b8-a94e-117474b9efc5" />
- **Agent Collaboration**: Support for role definition, task allocation, and multi-turn autonomous decision-making.
Communication protocol for remote heterogeneous agents coming soon.
- **Multi-Modal Models**: Seamless integration with OpenAI, Claude, DeepSeek, and other leading LLMs through a unified
API.
- **Extensible Tools**: Built-in search engines, browser automation, file system access, and terminal tools. MCP
protocol support coming soon for even more tool extensions.
- **Multi-Platform**: Run via CLI, Docker, or SDK. WebUI and integration with common software coming soon.
## Demo
https://github.com/user-attachments/assets/a0e565c4-94ef-4ddf-843d-a0c5aab640c6
## Quick Start
Choose one of these three ways to build and run your agent team:
### 1. Terminal
Run a multi-agent team from your command line:
#### 1.1 Installation
**Requirements:** Linux, MacOS, or Windows with Python installed.
> Python 3.11+ recommended (especially for browser tools), at least python 3.7+ required.
> Download from: [Python.org](https://www.python.org/downloads/).
Clone the repo and navigate to the project:
```bash
git clone https://github.com/MinimalFuture/AgentMesh
cd AgentMesh
```
Install core dependencies:
```bash
pip install -r requirements.txt
```
For browser tools, install additional dependencies (python3.11+ required):
```bash
pip install browser-use==0.1.40
playwright install
```
#### 1.2 Configuration
Edit the `config.yaml` file with your model settings and agent configurations:
```bash
cp config-template.yaml config.yaml
```
Add your model `api_key` - AgentMesh supports `openai`, `claude`, `deepseek`, `qwen`, and others.
> The template includes two examples:
> - `general_team`: A general-purpose agent for search and research tasks.
> - `software_team`: A development team with three roles that collaborates on web applications.
>
> You can add your own custom teams, and customize models, tools, and system prompts for each agent.
#### 1.3 Execution
You can run tasks directly using command-line arguments, specifying the team with `-t` and your question with `-q`:
```bash
python main.py -t general_team -q "analyze the trends in multi-agent technology"
python main.py -t software_team -q "develop a simple trial booking page for AgentMesh multi-agent platform"
```
Alternatively, enter interactive mode for multi-turn conversations:
```bash
python main.py -l # List available agent teams
python main.py -t software_team # Run the 'software_team'
```
### 2. Docker
Download the docker-compose configuration file:
```bash
curl -O https://raw.githubusercontent.com/MinimalFuture/AgentMesh/main/docker-compose.yml
```
Download the configuration template and add your model API keys (see section 1.2 for configuration details):
```bash
curl -o config.yaml https://raw.githubusercontent.com/MinimalFuture/AgentMesh/main/config-template.yaml
```
Run the Docker container:
```bash
docker-compose run --rm agentmesh bash
```
Once the container starts, you'll enter the command line. The usage is the same as in section 1.3 - specify a team to
start the interactive mode:
```bash
python main.py -l # List available agent teams
python main.py -t general_team # Start multi-turn conversation with the specified team
```
### 3. SDK
Use the AgentMesh SDK to build custom agent teams programmatically:
```bash
pip install agentmesh-sdk
```
#### 3.1 Single Agent
Run a single super-agent directly without a team, with multi-turn conversation support:
```python
from agentmesh import Agent, LLMModel
from agentmesh.tools import *
# Initialize model
model = LLMModel(model="gpt-4.1", api_key="YOUR_API_KEY")
# Create a single agent with tools
agent = Agent(
name="Assistant",
description="A versatile assistant",
system_prompt="You are a helpful assistant who answers questions using available tools.",
model=model,
tools=[GoogleSearch(), Calculator()]
)
# Single-turn call
response = agent.run_stream("What are the latest trends in multi-agent AI?")
# Multi-turn conversation (history is retained automatically)
agent.run_stream("My project is named AgentMesh")
agent.run_stream("Write a brief intro for my project") # Remembers the project name
```
#### 3.2 Agent Team
Build a multi-agent team where agents collaborate on complex tasks (replace `YOUR_API_KEY` with your actual API key):
```python
from agentmesh import AgentTeam, Agent, LLMModel
from agentmesh.tools import *
# Initialize model
model = LLMModel(model="gpt-4.1", api_key="YOUR_API_KEY")
# Create team and add agents
team = AgentTeam(name="software_team", description="A software development team", model=model)
team.add(Agent(name="PM", description="Handles product requirements",
system_prompt="You are an experienced PM who creates clear, comprehensive PRDs"))
team.add(Agent(name="Developer", description="Implements code based on requirements", model=model,
system_prompt="You write clean, efficient, maintainable code following requirements precisely",
tools=[Calculator(), GoogleSearch()]))
# Execute task
result = team.run(task="Write a Snake client game")
```
### 4. Web Service
Coming soon
## Components
### Core Concepts
- **Agent**: Autonomous decision-making unit with specific roles and capabilities, configurable with models, system
prompts, tools, and decision logic.
- **AgentTeam**: Team of agents responsible for task allocation, context management, and collaboration workflow.
- **Tool**: Functional modules that extend agent capabilities, such as calculators, search engines, and browsers.
- **Task**: User input problems or requirements, which can include text, images, and other multi-modal content.
- **Context**: Shared information including team details, task content, and execution history.
- **LLMModel**: Large language model interface supporting various mainstream LLMs through a unified API.
### Supported Models
- **OpenAI**: GPT series models, recommended: `gpt-4.1`, `gpt-4o`, `gpt-4.1-mini`
- **Claude**: Claude series models, recommended: `claude-sonnet-4-0`, `claude-3-7-sonnet-latest`
- **DeepSeek**: DeepSeek series models, recommended: `deepseek-chat`
- **Ollama**: Local open-source models (coming soon)
### Built-in Tools
- **calculator**: Mathematical calculation tool supporting complex expression evaluation
- **current_time**: Current time retrieval tool solving model time awareness issues
- **browser**: Web browsing tool based on browser-use, supporting web access, content extraction, and interaction
- **google_search**: Search engine tool for retrieving up-to-date information
- **file_save**: Tool for saving agent outputs to the local workspace
- **terminal**: Command-line tool for executing system commands safely with security restrictions
- **MCP**: Extended tool capabilities through MCP protocol support (coming soon)
## Contribution
⭐️ Star this project to receive notifications about updates.
Feel free to [submit PRs](https://github.com/MinimalFuture/AgentMesh/pulls) to contribute to this project.
For issues or ideas, please [open an issue](https://github.com/MinimalFuture/AgentMesh/issues).
| text/markdown | Minimal Future | zyj@zhayujie.com | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | https://github.com/MinimalFuture/AgentMesh | null | >=3.7 | [] | [] | [] | [
"requests==2.32.3",
"urllib3==1.26.20",
"pyyaml==6.0.1",
"pydantic",
"fastapi==0.104.1",
"uvicorn[standard]==0.24.0",
"websocket-client==1.7.0",
"pypdf>=4.0.0",
"browser-use>=0.1.40; extra == \"full\""
] | [] | [] | [] | [] | twine/4.0.2 CPython/3.9.12 | 2026-02-21T04:18:04.422171 | agentmesh_sdk-0.1.5-py3-none-any.whl | 126,074 | c0/02/86cd214b4435c4abd1ffde68b7e8a4eef02ba516b146ea4dfb9f57c35679/agentmesh_sdk-0.1.5-py3-none-any.whl | py3 | bdist_wheel | null | false | eff4f8fe79e16c66a8e36b3a1731bfa3 | 0cbd90f5a1e183230c87ee9309afbdaab2d347065c6c1ed54132d4cdc4082aa8 | c00286cd214b4435c4abd1ffde68b7e8a4eef02ba516b146ea4dfb9f57c35679 | null | [] | 105 |
2.4 | ubuntu-namer | 1.1.0 | Generate random Ubuntu-style codenames like Agile Amoeba | # ubuntu-namer
Generates random Ubuntu-style names like "Bamboozling Barnacle" and "Xenial Xenops". Over 15,000 unique combinations.
## CLI
```bash
$ uvx ubuntu-namer
Cosmic Cow
$ uvx ubuntu-namer --letter k
Kinetic Kittiwake
$ uvx ubuntu-namer --style snake
keen_kittiwake
$ uvx ubuntu-namer --letter g --style dot
galloping.gannet
```
## Library
```python
from ubuntu_namer import generate_name
generate_name() # "Haughty Humpback"
generate_name("u") # "Unassailable Uakari"
generate_name("s", style="camel") # "sarcasticStarfish"
generate_name(style="kebab") # "ultimate-uguisu"
```
## Styles
```
title Zen Zebu
lower giggling gecko
upper DILIGENT DRAKE
camel remarkableRedbird
pascal EvangelizingEagle
snake idyllic_inosaurus
kebab furious-fieldmouse
dot quick.quahog
```
| text/markdown | Richard Decal | null | null | null | null | null | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.13 | [] | [] | [] | [
"rich>=14.3.3",
"typer>=0.24.0"
] | [] | [] | [] | [
"Homepage, https://github.com/crypdick/ubuntu-namer",
"Repository, https://github.com/crypdick/ubuntu-namer"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:15:22.000321 | ubuntu_namer-1.1.0.tar.gz | 16,023 | c9/48/7d35c1a225f3229317ec12c504792946beda0e96aa322d509ab085f7acb9/ubuntu_namer-1.1.0.tar.gz | source | sdist | null | false | dffd37ff6b6422a951b6388d74eccef0 | 00cec36f84bba3adc6acf3c5373db6425b3230b9befd784455e28bd0be6e53fa | c9487d35c1a225f3229317ec12c504792946beda0e96aa322d509ab085f7acb9 | MIT | [
"LICENSE"
] | 228 |
2.4 | pulumi-webflow | 0.10.0 | Unofficial community-maintained Pulumi provider for managing Webflow sites, redirects, and robots.txt. Not affiliated with Pulumi Corporation or Webflow, Inc. | # Webflow Pulumi Provider
[](https://github.com/JDetmar/pulumi-webflow/actions)
[](https://opensource.org/licenses/MIT)
[](https://www.npmjs.com/package/@jdetmar/pulumi-webflow)
[](https://pypi.org/project/pulumi-webflow/)
[](https://www.nuget.org/packages/Community.Pulumi.Webflow)
[](https://pkg.go.dev/github.com/JDetmar/pulumi-webflow/sdk/go/webflow)
[](https://goreportcard.com/report/github.com/JDetmar/pulumi-webflow)
> **⚠️ Unofficial Community Provider**
>
> This is an **unofficial, community-maintained** Pulumi provider for Webflow. It is **not affiliated with, endorsed by, or supported by Pulumi Corporation or Webflow, Inc.** This project is an independent effort to bring infrastructure-as-code capabilities to Webflow using Pulumi.
>
> - **Not an official product** - Created and maintained by the community
> - **No warranties** - Provided "as-is" under the MIT License
> - **Community support only** - Issues and questions via [GitHub](https://github.com/JDetmar/pulumi-webflow/issues)
**Manage your Webflow sites and resources as code using Pulumi**
The Webflow Pulumi Provider lets you programmatically manage Webflow resources using the same Pulumi infrastructure-as-code approach you use for cloud resources. Manage sites, pages, collections, redirects, webhooks, assets, and more. Deploy, preview, and destroy Webflow infrastructure alongside your other cloud deployments.
## What You Can Do
- **Deploy Webflow resources as code** - Define sites, pages, collections, redirects, webhooks, assets, and more in TypeScript, Python, Go, C#, or Java
- **Preview before deploying** - Use `pulumi preview` to see exactly what will change
- **Manage multiple environments** - Create separate stacks for dev, staging, and production
- **Version control your infrastructure** - Track all changes in Git
- **Integrate with CI/CD** - Automate deployments in your GitHub Actions, GitLab CI, or other pipelines
## Table of Contents
1. [Prerequisites](#prerequisites)
2. [Installation](#installation)
3. [Quick Start](#quick-start) - Start here
4. [Authentication](#authentication)
5. [Verification](#verification)
6. [Get Help](#get-help)
7. [Version Control & Audit Trail](#version-control--audit-trail)
8. [Multi-Language Examples](#multi-language-examples)
9. [Next Steps](#next-steps)
10. [Contributing](#contributing)
---
## Prerequisites
Before you begin, make sure you have:
### 1. **Pulumi CLI**
- Download and install from [pulumi.com/docs/install](https://www.pulumi.com/docs/install/)
- Verify installation: `pulumi version` (requires v3.0 or later)
### 2. **Programming Language Runtime** (choose at least one)
- **TypeScript**: [Node.js](https://nodejs.org/) 18.x or later
- **Python**: [Python](https://www.python.org/downloads/) 3.9 or later
- **Go**: [Go](https://golang.org/dl/) 1.21 or later
- **C#**: [.NET](https://dotnet.microsoft.com/download) 6.0 or later
- **Java**: [Java](https://adoptopenjdk.net/) 11 or later
### 3. **Webflow Account**
- A Webflow account with API access enabled
- Access to at least one Webflow site (where you'll deploy your first resource)
### 4. **Webflow API Token**
- Your Webflow API token (see [Authentication](#authentication) section below)
---
## Installation
The Webflow provider installs automatically when you first run `pulumi up`. For manual installation:
```bash
# Automatic installation (recommended - happens on first pulumi up/preview)
# Just run the Quick Start below, and the provider will install automatically
# OR manual installation if you prefer
pulumi plugin install resource webflow
# Verify installation
pulumi plugin ls | grep webflow
```
---
## Quick Start
### Deploy Your First Webflow Resource in Under 20 Minutes
This quick start walks you through deploying a robots.txt resource to your Webflow site using TypeScript. The entire process takes about 5 minutes once prerequisites are met.
### Step 1: Create a New Pulumi Project (2 minutes)
```bash
# Create a new directory for your Pulumi project
mkdir my-webflow-project
cd my-webflow-project
# Initialize a new Pulumi project
pulumi new --template typescript
# When prompted:
# - Enter a project name: my-webflow-project
# - Enter a stack name: dev
# - Enter a passphrase (or leave empty for no encryption): <press enter>
```
This creates:
- `Pulumi.yaml` - Project configuration
- `Pulumi.dev.yaml` - Stack-specific settings
- `index.ts` - Your infrastructure code
- `package.json` - Node.js dependencies
### Step 2: Configure Webflow Authentication (3 minutes)
```bash
# Get your Webflow API token (see Authentication section below if you don't have one)
# Set your token in Pulumi config (encrypted in Pulumi.dev.yaml)
pulumi config set webflow:apiToken --secret
# When prompted, paste your Webflow API token and press Enter
```
**What's happening:** Your token is encrypted and stored locally in `Pulumi.dev.yaml` (which is in .gitignore). It's never stored in plain text.
### Step 3: Write Your First Resource (5 minutes)
Replace the contents of `index.ts` with:
```typescript
import * as pulumi from "@pulumi/pulumi";
import * as webflow from "@jdetmar/pulumi-webflow";
// Get config values
const config = new pulumi.Config();
const siteId = config.requireSecret("siteId"); // We'll set this next
// Deploy a robots.txt resource
const robotsTxt = new webflow.RobotsTxt("my-robots", {
siteId: siteId,
content: `User-agent: *
Allow: /
User-agent: Googlebot
Allow: /
`, // Standard robots.txt allowing all crawlers
});
// Export the site ID for reference
export const deployedSiteId = siteId;
```
### Step 4: Configure Your Site ID (2 minutes)
```bash
# Find your Webflow site ID (24-character hex string) from Webflow Designer
# You can find it in: Project Settings > API & Webhooks > Site ID
# Set it in your Pulumi config
pulumi config set siteId --secret
# When prompted, paste your 24-character site ID and press Enter
```
**Need help finding your site ID?**
- In Webflow Designer, go to **Project Settings** (bottom of sidebar)
- Click **API & Webhooks**
- Your **Site ID** is displayed as a 24-character hex string (e.g., `5f0c8c9e1c9d440000e8d8c3`)
### Step 5: Preview Your Deployment (2 minutes)
```bash
# Install dependencies
npm install
# Preview the changes Pulumi will make
pulumi preview
```
Expected output:
```
Previewing update (dev):
Type Name Plan Info
+ webflow:RobotsTxt my-robots create
Resources:
+ 1 to create
Do you want to perform this update?
> yes
no
details
```
### Step 6: Deploy! (2 minutes)
```bash
# Deploy to your Webflow site
pulumi up
```
When prompted, select **yes** to confirm the deployment.
Expected output:
```
Type Name Plan Status
+ webflow:RobotsTxt my-robots create created
Outputs:
deployedSiteId: "5f0c8c9e1c9d440000e8d8c3"
Resources:
+ 1 created
Duration: 3s
```
### Step 7: Verify in Webflow (2 minutes)
1. Open Webflow Designer
2. Go to **Project Settings** → **SEO** → **robots.txt**
3. You should see the robots.txt content you deployed!
### Step 8: Clean Up (Optional)
```bash
# Remove the resource from Webflow
pulumi destroy
# When prompted, select 'yes' to confirm
```
**Congratulations!** You've successfully deployed your first Webflow resource using Pulumi! 🎉
---
## Authentication
### Getting Your Webflow API Token
1. Log in to [Webflow](https://webflow.com)
2. Go to **Account Settings** (bottom left of screen)
3. Click **API Tokens** in the left sidebar
4. Click **Create New Token**
5. Name it something descriptive (e.g., "Pulumi Provider")
6. Grant the following permissions:
- **Sites**: Read & Write
- **Redirects**: Read & Write (if using Redirect resources)
- **Robots.txt**: Read & Write (if using RobotsTxt resources)
7. Click **Create Token**
8. **Copy the token immediately** - Webflow won't show it again
### Setting Up Your Token in Pulumi
```bash
# Option 1: Pulumi config (recommended - encrypted in Pulumi.dev.yaml)
pulumi config set webflow:apiToken --secret
# Option 2: Environment variable
export WEBFLOW_API_TOKEN="your-token-here"
# Option 3: Code (NOT RECOMMENDED for production - security risk)
# Don't do this in production code!
```
### Security Best Practices
- ✅ **DO** use Pulumi config with `--secret` flag (encrypts locally)
- ✅ **DO** use environment variables in CI/CD pipelines
- ✅ **DO** keep tokens in `.env` files (never commit to Git)
- ❌ **DON'T** commit tokens to Git
- ❌ **DON'T** hardcode tokens in your Pulumi program
- ❌ **DON'T** share tokens via email or chat
- 🔐 **Rotate tokens regularly** - Create new tokens and retire old ones monthly
### CI/CD Configuration
For GitHub Actions or other CI/CD:
```yaml
# .github/workflows/deploy.yml
env:
WEBFLOW_API_TOKEN: ${{ secrets.WEBFLOW_API_TOKEN }}
PULUMI_ACCESS_TOKEN: ${{ secrets.PULUMI_ACCESS_TOKEN }}
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: pulumi/actions@v6
with:
command: up
```
---
## Verification
### Confirm Your Installation
```bash
# Check Pulumi is installed
pulumi version
# Check the Webflow provider is available
pulumi plugin ls | grep webflow
# Should output something like:
# resource webflow 1.0.0-alpha.0+dev
```
### Verify Authentication Works
```bash
# Inside a Pulumi project directory:
pulumi preview
# If authentication fails, you'll see an error like:
# Error: Unauthorized - Check your Webflow API token
```
### After Deployment
1. **In Webflow Designer:**
- Check that your resource appears in the appropriate settings (robots.txt, redirects, etc.)
- Verify the configuration matches what you deployed
2. **Via Pulumi:**
```bash
pulumi stack output deployedSiteId
# Should output your 24-character site ID
```
3. **Via Command Line:**
```bash
# View your stack's resources
pulumi stack select dev
pulumi stack
# View detailed resource information
pulumi stack export | jq .
```
---
## Get Help
- [Troubleshooting Guide](./docs/troubleshooting.md) - Comprehensive error reference and solutions
- [FAQ](./docs/faq.md) - Answers to common questions
- [Examples](./examples/) - Working code for all resources
- [GitHub Issues](https://github.com/JDetmar/pulumi-webflow/issues) - Report bugs
- [GitHub Discussions](https://github.com/JDetmar/pulumi-webflow/discussions) - Ask questions
---
## Version Control & Audit Trail
Track all infrastructure changes in Git for compliance and auditability. Features include automatic audit trails, code review via pull requests, and SOC 2/HIPAA/GDPR-ready reporting.
See the [Version Control Guide](./docs/version-control.md) for Git workflows, commit conventions, and audit report generation.
---
## Multi-Language Examples
The Quick Start uses TypeScript. Complete examples for all languages are in [examples/quickstart/](./examples/quickstart/):
- [TypeScript](./examples/quickstart/typescript/) | [Python](./examples/quickstart/python/) | [Go](./examples/quickstart/go/)
Each includes setup instructions, complete code, and a README.
---
## Next Steps
Once you've completed the Quick Start:
### 1. **Explore More Resources**
- Deploy multiple resource types (Redirects, Sites, etc.)
- Use the [examples/](./examples/) directory for real-world patterns
- Check [docs/](./docs/) for comprehensive reference documentation
### 2. **Multi-Environment Setup**
- Create separate stacks for dev, staging, and production
- Use different site IDs for each environment
- See: [examples/stack-config/](./examples/stack-config/)
### 3. **Advanced Patterns**
- Multi-site management: [examples/multi-site/](./examples/multi-site/)
- CI/CD integration: [examples/ci-cd/](./examples/ci-cd/)
- Logging and troubleshooting: [examples/troubleshooting-logs/](./examples/troubleshooting-logs/)
### 4. **Learn Pulumi Concepts**
- [Pulumi Documentation](https://www.pulumi.com/docs/)
- [Getting Started with Pulumi](https://www.pulumi.com/docs/iac/getting-started/)
- [Pulumi Best Practices](https://www.pulumi.com/docs/using-pulumi/best-practices/)
### 5. **Connect with the Community**
- [Pulumi Community Slack](https://pulumi-community.slack.com/)
- [Pulumi GitHub Discussions](https://github.com/pulumi/pulumi/discussions)
---
## Contributing
We welcome contributions! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
### Ways to Contribute
- **Report bugs** - Found an issue? [Create a GitHub issue](https://github.com/JDetmar/pulumi-webflow/issues)
- **Submit improvements** - Have an idea? [Create a discussion](https://github.com/JDetmar/pulumi-webflow/discussions)
- **Contribute code** - Fork the repo, make changes, and submit a pull request
- **Improve documentation** - Help us document features and patterns
---
## License
This project is licensed under the MIT License - see [LICENSE](./LICENSE) file for details.
---
## Troubleshooting Quick Reference
| Problem | Solution |
|---------|----------|
| Plugin not found | `pulumi plugin install resource webflow` |
| Invalid token | Check Webflow Account Settings → API Tokens |
| Invalid site ID | Verify in Webflow Designer → Project Settings → API & Webhooks |
| Deployment times out | Check internet connection, try again |
| Token format error | Ensure you're using the full API token (not just a prefix) |
| Site not found | Verify site ID matches the site where you want to deploy |
| Need detailed logs | Enable debug logging: `PULUMI_LOG_LEVEL=debug pulumi up` - See [Logging Guide](./docs/logging.md) |
For more troubleshooting help and detailed logging documentation:
- **[Logging and Debugging Guide](./docs/logging.md)** - Comprehensive guide to structured logging features
- **[Troubleshooting Guide](./docs/troubleshooting.md)** - Common issues and detailed solutions
- **[Changelog](./CHANGELOG.md)** - Release history and notable changes
---
**Ready to get started?** Jump to [Quick Start](#quick-start) above! 🚀
| text/markdown | null | null | null | null | null | null | [] | [] | https://github.com/JDetmar/pulumi-webflow | null | >=3.9 | [] | [] | [] | [
"parver>=0.2.1",
"pulumi<4.0.0,>=3.165.0",
"semver>=2.8.1",
"typing-extensions<5,>=4.11; python_version < \"3.11\""
] | [] | [] | [] | [
"Repository, https://github.com/JDetmar/pulumi-webflow"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:15:03.870994 | pulumi_webflow-0.10.0.tar.gz | 42,477 | cc/3a/0ca396678804d4cee2e0e44a4be1911700f4668c994bd56c55351be0b720/pulumi_webflow-0.10.0.tar.gz | source | sdist | null | false | e8912bc39cafbb45ead68686e18227e3 | 1464a1d0423fdce36d44dd924d2bf6006921ce34855d021768d5ae8d8b33a8dc | cc3a0ca396678804d4cee2e0e44a4be1911700f4668c994bd56c55351be0b720 | null | [] | 239 |
2.4 | skyward | 0.3.0 | Execute Python functions on cloud compute with a simple decorator | <p align="center">
<img src="docs/logo_sky.png" alt="Skyward" width="400">
</p>
<p align="center">
<strong>Cloud accelerators with a single decorator</strong>
</p>
<p align="center">
<a href="https://github.com/gabfssilva/skyward/actions/workflows/python-package.yml"><img src="https://github.com/gabfssilva/skyward/actions/workflows/python-package.yml/badge.svg" alt="CI"></a>
<a href="https://pypi.org/project/skyward/"><img src="https://img.shields.io/pypi/v/skyward" alt="PyPI"></a>
<a href="https://pypi.org/project/skyward/"><img src="https://img.shields.io/pypi/pyversions/skyward" alt="Python"></a>
<a href="https://github.com/gabfssilva/skyward/blob/main/LICENSE"><img src="https://img.shields.io/github/license/gabfssilva/skyward" alt="License"></a>
</p>
---
Skyward is a Python library for ephemeral accelerator compute. Spin up cloud accelerators, run your code, and tear them down automatically. No infrastructure to manage, no idle costs.
## Quick Example
```python
import skyward as sky
@sky.compute
def train(epochs: int) -> dict:
import torch
model = torch.nn.Linear(100, 10).cuda()
optimizer = torch.optim.Adam(model.parameters())
for epoch in range(epochs):
loss = model(torch.randn(32, 100, device="cuda")).sum()
loss.backward()
optimizer.step()
return {"final_loss": loss.item()}
with sky.ComputePool(provider=sky.AWS(), accelerator="T4", image=sky.Image(pip=["torch"])) as pool:
result = train(epochs=100) >> pool
print(result)
```
## Features
- **[One decorator, any cloud](https://gabfssilva.github.io/skyward/concepts/)** — `@compute` makes any function remotely executable. AWS, RunPod, VastAI, and Verda with a unified API.
- **[Operators, not boilerplate](https://gabfssilva.github.io/skyward/concepts/)** — `>>` executes on one node, `@` broadcasts to all, `&` runs in parallel. No job configs, no YAML.
- **[Ephemeral by default](https://gabfssilva.github.io/skyward/concepts/)** — Instances provision on demand and terminate automatically. Context managers guarantee cleanup.
- **[Multi-provider support](https://gabfssilva.github.io/skyward/providers/)** — AWS, RunPod, VastAI, Verda with automatic fallback and cost optimization.
- **[Distributed training](https://gabfssilva.github.io/skyward/distributed-training/)** — PyTorch DDP, Keras 3, JAX, TensorFlow, and HuggingFace integration decorators.
- **[Distributed collections](https://gabfssilva.github.io/skyward/distributed-collections/)** — Dict, set, counter, queue, barrier, and lock replicated across the cluster.
- **[Spot-aware](https://gabfssilva.github.io/skyward/providers/)** — Automatic spot instance selection, preemption detection, and replacement. Save 60-90% on compute costs.
## Install
```bash
uv add skyward
```
## Requirements
- Python 3.12+
- Cloud provider credentials ([setup guide](https://gabfssilva.github.io/skyward/getting-started/))
## Documentation
Full documentation at **[gabfssilva.github.io/skyward](https://gabfssilva.github.io/skyward/)**.
## License
MIT
| text/markdown | Gabriel Francisco | null | null | null | MIT | cloud, compute, distributed, gpu, serverless | [
"Development Status :: 3 - Alpha",
"Framework :: AsyncIO",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Software Development :: Libraries :: Python Modules",
"Typing :: Typed"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"aiohttp>=3.13.3",
"asyncssh>=2.22.0",
"casty>=0.18.0",
"cloudpickle>=3.1.2",
"pydantic>=2.12.5",
"rich>=14.3.2",
"accelerate>=1.12.0; extra == \"all\"",
"aioboto3>=13.0.0; extra == \"all\"",
"azure-mgmt-containerinstance>=10.0; extra == \"all\"",
"boto3-stubs[ec2,ecr,iam,s3,sts]>=1.35.0; extra == \"all\"",
"datasets>=4.4.1; extra == \"all\"",
"google-auth>=2.0.0; extra == \"all\"",
"google-cloud-compute>=1.20.0; extra == \"all\"",
"google-cloud-tpu>=1.25.0; extra == \"all\"",
"torch==2.8.0; extra == \"all\"",
"torchvision==0.23.0; extra == \"all\"",
"transformers>=4.57.3; extra == \"all\"",
"verda>=1.0.0; extra == \"all\"",
"aioboto3>=13.0.0; extra == \"aws\"",
"boto3-stubs[ec2,ecr,iam,s3,sts]>=1.35.0; extra == \"aws\"",
"azure-mgmt-containerinstance>=10.0; extra == \"azure\"",
"boto3-stubs[ec2,ecr,iam,s3,ssm,sts]>=1.42.3; extra == \"dev\"",
"jax>=0.8.1; extra == \"dev\"",
"keras>=3.12.0; extra == \"dev\"",
"mypy>=1.13; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.8; extra == \"dev\"",
"torch>=2.8.0; extra == \"dev\"",
"google-auth>=2.0.0; extra == \"gcp\"",
"google-cloud-compute>=1.20.0; extra == \"gcp\"",
"google-cloud-tpu>=1.25.0; extra == \"gcp\"",
"accelerate>=1.12.0; extra == \"huggingface\"",
"datasets>=4.4.1; extra == \"huggingface\"",
"transformers>=4.57.3; extra == \"huggingface\"",
"pandas==2.3.3; extra == \"pandas\"",
"aioboto3>=13.0.0; extra == \"providers\"",
"azure-mgmt-containerinstance>=10.0; extra == \"providers\"",
"boto3-stubs[ec2,ecr,iam,s3,sts]>=1.35.0; extra == \"providers\"",
"google-auth>=2.0.0; extra == \"providers\"",
"google-cloud-compute>=1.20.0; extra == \"providers\"",
"google-cloud-tpu>=1.25.0; extra == \"providers\"",
"verda>=1.0.0; extra == \"providers\"",
"torch==2.8.0; extra == \"pytorch\"",
"torchvision==0.23.0; extra == \"pytorch\"",
"verda>=1.0.0; extra == \"verda\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:14:57.816186 | skyward-0.3.0.tar.gz | 1,424,220 | c6/f0/5df5e5fd4650e1a52a1fd5c9448fbc31d7c9da8dc923cd8a7a9cfe0ec343/skyward-0.3.0.tar.gz | source | sdist | null | false | 47f47eb2a770c464dd91b967a41361c2 | 5a85ea22ebcff69c3dabb508143067541bbad660592fbc2de420d26ac81777db | c6f05df5e5fd4650e1a52a1fd5c9448fbc31d7c9da8dc923cd8a7a9cfe0ec343 | null | [
"LICENSE"
] | 261 |
2.4 | jadegate | 0.1.0 | JadeGate - Deterministic Security for AI Agent Skills | <div align="center">
# 💠 JadeGate
### *Deterministic Security for AI Agent Skills*
**"Code is fluid. Jade is solid."**
**以玉为契，不可篡改。**
[](https://opensource.org/licenses/MIT)
[](#skill-registry)
[](#jade-schema)
[](https://crates.io/crates/jadegate)
---
*羌笛何须怨杨柳，春风不度玉门关。*
*Malicious code shall not pass the JadeGate.*
</div>
---
## What is JADE?
**JADE** (JSON-based Agent Deterministic Execution) is a zero-trust security protocol for AI Agent skills.
Every skill is a pure JSON file — non-Turing-complete, structurally verifiable, mathematically provable safe.
No `eval()`. No `exec()`. No `import`. No exceptions.
```
💠 JADE Verified — Passed all 5 security layers
❌ Rejected — Blocked: executable code / dangerous patterns detected
```
## Why JADE?
Traditional AI skills (Markdown files, Python scripts) are **inherently unsafe**:
- They can contain hidden executable code
- They can exfiltrate private data
- They can be prompt-injected
JADE makes safety a **structural property**, not a behavioral one:
| | Traditional Skills | JADE Skills |
|---|---|---|
| Format | Markdown / Python | Pure JSON (non-Turing-complete) |
| Safety | Review-based (hope for the best) | Structural (mathematically proven) |
| Verification | Manual | Automated 5-layer validation |
| Execution | Arbitrary code | Deterministic DAG |
## 5-Layer Security Validation
```
Layer 1: JSON Schema — structural integrity
Layer 2: Code Injection — 22 executable patterns blocked
Layer 3: Dangerous Commands — 25+ system commands blocked
Layer 4: Network & Data — whitelist enforcement + data leak prevention
Layer 5: DAG Safety — cycle detection + reachability proof
```
All layers pass = 💠. Any layer fails = ❌.
## Install
```bash
# Python
pip install jadegate
# Rust
cargo add jadegate
```
## Quick Start
```python
from jade_core.validator import JadeValidator
from jade_core.client import JadeClient
# Validate a skill
validator = JadeValidator()
result = validator.validate_file("jade_skills/weather_api.json")
print(f"Valid: {result.valid}") # True
# Load and use skills
client = JadeClient()
skill = client.load_file("jade_skills/weather_api.json")
print(skill.execution_dag.entry_node)
```
## Skill Registry
35 verified skills across 8 categories:
| Category | Skills | Examples |
|----------|--------|---------|
| 🌐 Web & Search | 6 | web_search, webpage_screenshot, rss_reader |
| 📡 API Integration | 5 | notion, github, exa, slack, discord |
| 🔧 System & DevOps | 6 | git_clone, docker, ssh, sqlite, shell |
| 📁 File Operations | 4 | file_rename, csv_analysis, pdf_parser, hash_verify |
| 🔒 Network & Security | 5 | dns_lookup, ssl_check, whois, health_check, ip_geo |
| 💬 Messaging | 3 | slack, discord, telegram |
| 🧠 AI & NLP | 3 | translation, sentiment, content_extract |
| 🛠️ Utilities | 3 | timezone, qr_code, base64, json_transform |
## Architecture
```
┌─────────────────────────────────────────┐
│ JADE Skill (JSON) │
│ ┌─────────┐ ┌──────┐ ┌───────────┐ │
│ │ Trigger │→ │ DAG │→ │ Output │ │
│ └─────────┘ └──────┘ └───────────┘ │
└──────────────────┬──────────────────────┘
│ validate
┌──────────────────▼──────────────────────┐
│ JadeValidator (5 layers) │
│ Schema → Injection → Commands → │
│ Network → DAG Safety │
└──────────────────┬──────────────────────┘
│
💠 or ❌
```
## MCP Compatible
JADE skills are fully compatible with the [Model Context Protocol](https://modelcontextprotocol.io/). Use JADE as the security layer on top of MCP:
> *"Use MCP to connect. Use JADE to protect."*
## Project Structure
```
jade-core/
├── jade_core/ # Core Python library
│ ├── validator.py # 5-layer security validator
│ ├── security.py # Zero-trust security engine
│ ├── dag.py # DAG analyzer
│ ├── client.py # Client SDK
│ ├── registry.py # Bayesian confidence registry
│ └── models.py # Data models
├── jade_schema/ # JSON Schema + allowed actions
├── jade_skills/ # Official verified skills (💠)
├── converted_skills/ # Community skills (✅)
├── jade_registry/ # Skill index
├── tests/ # 135 test cases
└── tools/ # Converters and utilities
```
## Roadmap
- [x] v0.1 — Core validator + 35 skills + schema
- [ ] v0.2 — `jade list` / `jade verify` / `jade install` CLI
- [ ] v0.3 — Cryptographic signing (🔏 JADE Sealed)
- [ ] v0.4 — Bayesian trust routing + global attestation network
- [ ] v0.5 — Rust client for 10ms verification
## Contributing
We welcome skill contributions! Every submitted skill must pass all 5 validation layers.
```bash
# Validate your skill before submitting
python -c "
from jade_core.validator import JadeValidator
v = JadeValidator()
r = v.validate_file('your_skill.json')
print('💠 Verified' if r.valid else '❌ Rejected')
for i in r.errors: print(f' {i.message}')
"
```
## License
MIT — Free to use, free to build on.
---
<div align="center">
**💠 JadeGate** — *Pass the Gate. Trust the Jade.*
[GitHub](https://github.com/JadeGate) · [PyPI](https://pypi.org/project/jadegate/) · [crates.io](https://crates.io/crates/jadegate) · [Skills](./jade_skills/) · [Schema](./jade_schema/)
</div>
| text/markdown | JadeGate | jadegate@users.noreply.github.com | null | null | MIT | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Topic :: Security",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | https://github.com/JadeGate/jade-core | null | >=3.8 | [] | [] | [] | [
"pytest>=7.0; extra == \"dev\"",
"pytest-cov; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:14:31.568086 | jadegate-0.1.0-py3-none-any.whl | 25,915 | 51/67/f4b89898834503b72009f9c3f9f222b1dde0c21ad925475f86b3ca0425cd/jadegate-0.1.0-py3-none-any.whl | py3 | bdist_wheel | null | false | 6902638eb6ff0db06c046277e639b5e9 | 8e1dc562432ef8c8a74e67fbdf0472da8a8463d804fdea0487bcf7e939d9141f | 5167f4b89898834503b72009f9c3f9f222b1dde0c21ad925475f86b3ca0425cd | null | [] | 250 |
2.4 | sprocket-systems.coda.sdk | 2.1.2 | The Coda SDK provides a Python interface to define Coda workflows, create jobs and run them. | # Coda Python SDK
Coda provides a Python SDK that streamlines interactions with the core API. It provides the ability to define Coda workflows, create jobs, and run them.
Please see [the documentation](https://v2.coda.sprocket.systems/docs/sdks/python/) for more information.
| text/markdown | null | Sprocket Systems <support@sprocket.systems> | null | null | null | python, coda, sdk | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"requests",
"soundfile>=0.13.1"
] | [] | [] | [] | [
"Documentation, https://v2.coda.sprocket.systems/docs/sdks/python/"
] | twine/6.2.0 CPython/3.10.3 | 2026-02-21T04:14:30.283976 | sprocket_systems_coda_sdk-2.1.2.tar.gz | 37,258 | 8a/4a/b9b5b13cf7d2cef4efc940ceb00838a08872387d8ae6e8b5131004886b90/sprocket_systems_coda_sdk-2.1.2.tar.gz | source | sdist | null | false | 6063f625371a0ebbc7d4ac80025b3a83 | 7133e34cc0aa76afbc5ea9346e4b4359bb3737e1c542a0ea3c0941b29ffd83bb | 8a4ab9b5b13cf7d2cef4efc940ceb00838a08872387d8ae6e8b5131004886b90 | LicenseRef-Tomorrow-Open-Source-Technology-License-1.0 | [
"LICENSE"
] | 0 |
2.4 | geoxgb | 0.1.0 | Geometry-aware gradient boosting with HVRT-powered sample curation | # GeoXGB -- Geometry-Aware Gradient Boosting
GeoXGB replaces conventional subsampling and bootstrapping with geometry-aware
sample reduction and expansion powered by [HVRT](https://pypi.org/project/hvrt/)
(Hierarchical Variance-Retaining Transformer).
## Installation
```bash
pip install geoxgb
```
Requires `hvrt >= 2.1.0`, `scikit-learn`, and `numpy`. Python >= 3.10.
## Quick Start
```python
from geoxgb import GeoXGBRegressor, GeoXGBClassifier
# Regression
reg = GeoXGBRegressor(n_rounds=100, learning_rate=0.1)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
# Classification
clf = GeoXGBClassifier(n_rounds=100)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)
# Pass feature types for mixed data
clf.fit(X_train, y_train, feature_types=["continuous", "categorical", ...])
```
## Key Features
- **Geometry-aware sampling** via HVRT's variance-retaining partitions
- **FPS reduction** -- keeps geometrically diverse representatives
- **KDE expansion** -- synthesizes samples in sparse regions
- **Adaptive noise detection** -- automatically backs off on noisy data
- **Multi-fit** -- refits partitions on residuals every N rounds
- **Full interpretability** -- feature importances, partition traces, sample provenance
- **Categorical support** -- pass `feature_types` to handle mixed data natively
- **Class reweighting** -- `class_weight` for imbalanced classification
## Parameters
### Shared (GeoXGBRegressor and GeoXGBClassifier)
| Parameter | Default | Description |
|---|---|---|
| `n_rounds` | 100 | Number of boosting rounds |
| `learning_rate` | 0.1 | Shrinkage per tree |
| `max_depth` | 6 | Maximum depth of each weak learner |
| `min_samples_leaf` | 5 | Minimum samples per leaf |
| `n_partitions` | None | HVRT partition count (None = auto-tuned) |
| `reduce_ratio` | 0.7 | Fraction to keep via FPS |
| `expand_ratio` | 0.0 | Fraction to synthesize via KDE (0 = disabled) |
| `y_weight` | 0.5 | HVRT blend: 0 = unsupervised geometry, 1 = y-driven |
| `method` | `'fps'` | HVRT selection method |
| `variance_weighted` | True | Budget allocation by partition variance |
| `bandwidth` | 0.5 | KDE bandwidth for expansion |
| `refit_interval` | 10 | Refit partitions every N rounds (None = off) |
| `auto_noise` | True | Auto-detect noise and modulate resampling |
| `auto_expand` | True | Auto-expand small datasets to `min_train_samples` |
| `min_train_samples` | 5000 | Target training-set size when `auto_expand=True` |
| `cache_geometry` | False | Reuse HVRT partition structure across refits |
| `random_state` | 42 | |
### GeoXGBClassifier only
| Parameter | Default | Description |
|---|---|---|
| `class_weight` | None | `None`, `'balanced'`, or `{class: weight}` dict |
## Interpretability
```python
from geoxgb.report import model_report, print_report
# All-in-one structured report
print_report(model_report(model, X_test, y_test, feature_names=names))
# Individual report sections
from geoxgb.report import (
noise_report, # data quality assessment
provenance_report, # where did the training samples come from?
importance_report, # boosting vs partition feature importance
partition_report, # HVRT partition structure at a given round
evolution_report, # how geometry changed across refits
validation_report, # PASS/FAIL checks against known ground truth
compare_report, # head-to-head comparison with a baseline
)
# Raw model API
model.feature_importances(feature_names) # boosting importance
model.partition_feature_importances(feature_names) # geometric importance
model.partition_trace() # full partition history
model.partition_tree_rules(round_idx=0) # human-readable rules
model.sample_provenance() # reduction/expansion counts
model.noise_estimate() # 1.0=clean, 0.0=pure noise
```
## Imbalanced Classification
Use `class_weight='balanced'` to upweight the minority class in gradient
updates. This stacks with HVRT's geometric diversity preservation.
```python
clf = GeoXGBClassifier(
class_weight='balanced',
auto_noise=False, # recommended for severe imbalance (< 5% minority)
)
```
## Large-Scale Datasets
For datasets with many thousands of samples, HVRT refitting at each
`refit_interval` dominates wall time. Enable geometry caching to reuse the
initial partition structure and reduce HVRT.fit() calls from
`n_rounds / refit_interval` down to 1:
```python
model = GeoXGBRegressor(
cache_geometry=True, # reuse HVRT partition structure across refits
refit_interval=10,
)
```
**Trade-off**: caching freezes the partition structure at the geometry
learned from the initial y (raw targets / first gradients). Subsequent
refits still curate samples geometrically but do not re-adapt partitions
to the current residual distribution. For most datasets this is negligible;
set `cache_geometry=False` (the default) if partition adaptivity matters.
## Benchmarks
See [`benchmarks/`](benchmarks/) for classification and regression benchmarks
comparing GeoXGB against XGBoost, including hyperparameter optimisation to
validate the defaults and a full walkthrough of GeoXGB's unique
interpretability outputs.
## License
MIT
| text/markdown | null | null | null | null | MIT | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"numpy",
"scikit-learn",
"hvrt>=2.1.0",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.0 | 2026-02-21T04:14:08.473243 | geoxgb-0.1.0.tar.gz | 30,964 | 9a/4a/84fde2ad31cf9ba26ded60ccf33c279f5e4ea186764e53b10297a505bf6e/geoxgb-0.1.0.tar.gz | source | sdist | null | false | caa717a065a0be5147a7ede5888d70b7 | 9c16609f97140dd5a78fd7934d241ce36c9a6257445c740a210012c08902da66 | 9a4a84fde2ad31cf9ba26ded60ccf33c279f5e4ea186764e53b10297a505bf6e | null | [
"LICENSE"
] | 257 |
2.4 | yt-dlp-audio-normalize | 0.3.0 | yt-dlp postprocessor plugin for audio normalization using ffmpeg-normalize | # yt-dlp-audio-normalize
[ffmpeg-normalize](https://github.com/slhck/ffmpeg-normalize) を使用した音声正規化のための yt-dlp PostProcessor プラグイン
## 要件
- Python >= 3.10
- yt-dlp >= 2026.2.4
- ffmpeg (システムにインストール済みであること)
## インストール
```bash
pip install -U yt-dlp-audio-normalize
```
## 使い方
### --use-postprocessor
```bash
# デフォルトの正規化
yt-dlp --use-postprocessor AudioNormalize URL
# パラメータを指定
yt-dlp --use-postprocessor "AudioNormalize:target_level=-14.0;audio_codec=aac" URL
# 実行タイミングを指定
yt-dlp --use-postprocessor "AudioNormalize:when=after_move" URL
```
### --ppa (PostProcessor Arguments)
```bash
yt-dlp --ppa "AudioNormalize:-t -14.0 -c:a aac -b:a 128k" URL
```
`--use-postprocessor` の kwargs と `--ppa` の両方が指定された場合、PPA が優先される。
### Python API
```python
import yt_dlp
from yt_dlp_plugins.postprocessor.audio_normalize import AudioNormalizePP
with yt_dlp.YoutubeDL(opts) as ydl:
ydl.add_post_processor(AudioNormalizePP(), when="after_move")
ydl.download([url])
```
## サポートされるパラメータ
`FFmpegNormalize.__init__()` のすべてのスカラーパラメータは、ロングフラグ(例: `--target-level`, `--audio-codec`)で自動的にサポートされる
### ショートフラグ
| フラグ | パラメータ | 説明 |
| ------ | ----------- | ------ |
| `-nt` | `normalization_type` | 正規化タイプ |
| `-t` | `target_level` | ターゲットレベル |
| `-p` | `print_stats` | 統計情報の表示 |
| `-lrt` | `loudness_range_target` | ラウドネス範囲ターゲット |
| `-tp` | `true_peak` | トゥルーピーク |
| `-c:a` | `audio_codec` | 音声コーデック |
| `-b:a` | `audio_bitrate` | 音声ビットレート |
| `-ar` | `sample_rate` | サンプルレート |
| `-ac` | `audio_channels` | 音声チャンネル数 |
| `-koa` | `keep_original_audio` | 元の音声を保持 |
| `-prf` | `pre_filter` | プリフィルター |
| `-pof` | `post_filter` | ポストフィルター |
| `-vn` | `video_disable` | 映像を無効化 |
| `-c:v` | `video_codec` | 映像コーデック |
| `-sn` | `subtitle_disable` | 字幕を無効化 |
| `-mn` | `metadata_disable` | メタデータを無効化 |
| `-cn` | `chapters_disable` | チャプターを無効化 |
| `-ofmt` | `output_format` | 出力フォーマット |
| `-ext` | `extension` | 拡張子 |
| `-d` | `debug` | デバッグモード |
| `-n` | `dry_run` | ドライラン |
| `-pr` | `progress` | 進捗表示 |
## ライセンス
[Unlicense](LICENSE)
| text/markdown | 9c5s | null | null | null | null | audio, ffmpeg, loudness, normalization, yt-dlp | [
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Multimedia :: Sound/Audio"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"ffmpeg-normalize>=1.37.3"
] | [] | [] | [] | [
"Issues, https://github.com/9c5s/yt-dlp-AudioNormalize/issues",
"Repository, https://github.com/9c5s/yt-dlp-AudioNormalize"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:13:50.464222 | yt_dlp_audio_normalize-0.3.0.tar.gz | 17,603 | 96/c5/4638c0e5f328eafb7eefea28e0cb4f9819c850c36e3ee61c8aea3e6babde/yt_dlp_audio_normalize-0.3.0.tar.gz | source | sdist | null | false | 0f6a5ae51fdd47c68481338653151b07 | bf4e1b9540aa8dbc72b4f4050652e19c57f8772abc564faf72c35bf52514bd24 | 96c54638c0e5f328eafb7eefea28e0cb4f9819c850c36e3ee61c8aea3e6babde | Unlicense | [
"LICENSE"
] | 232 |
2.4 | agent-alignment-protocol | 0.2.0 | Agent Alignment Protocol - The missing alignment layer for the agent protocol stack | # Agent Alignment Protocol (AAP)
[](https://github.com/mnemom/aap/actions/workflows/ci.yml)
[](https://github.com/mnemom/aap/actions/workflows/codeql.yml)
[](https://codecov.io/gh/mnemom/aap)
[](https://pypi.org/project/agent-alignment-protocol/)
[](https://www.npmjs.com/package/@mnemom/agent-alignment-protocol)
[](LICENSE)
[](https://docs.mnemom.ai/protocols/aap/specification)
**A transparency protocol for autonomous agents.**
AAP lets agents declare their alignment posture, produce auditable decision traces, and verify value coherence before coordinating with other agents. It extends existing protocols (A2A, MCP) with an alignment layer that makes agent behavior observable.
> AAP is a transparency protocol, not a trust protocol. It makes agent behavior more observable, not more guaranteed.
## Quick Start
```bash
# Install
pip install agent-alignment-protocol
# Generate an Alignment Card
aap init --values "principal_benefit,transparency,harm_prevention"
# ✓ Created alignment-card.json
# Instrument your agent
```
```python
from aap import trace_decision
@trace_decision(card_path="alignment-card.json")
def recommend_product(user_preferences):
# Your agent logic here
# Decisions are automatically traced
...
```
```bash
# Verify behavior matches declaration
aap verify --card alignment-card.json --trace logs/trace.json
# ✓ Verified [similarity: 0.82]
# Checks: autonomy, escalation, values, forbidden, behavioral_similarity
```
## Why AAP?
The agent protocol stack provides capability discovery (A2A), tool integration (MCP), and payment authorization (AP2). None address a fundamental question: **Is this agent serving its principal's interests?**
| Protocol | Function | Gap |
|----------|----------|-----|
| **MCP** | Agent-to-tool connectivity | No alignment semantics |
| **A2A** | Task negotiation between agents | No value verification |
| **AP2** | Payment authorization | No behavioral audit |
As agent capabilities become symmetric—equal access to information, equal reasoning power—alignment becomes the primary differentiator. AAP provides the infrastructure to make alignment claims verifiable.
## Three Components
```
┌─────────────────┬─────────────────┬─────────────────┐
│ Alignment Card │ AP-Trace │ Value Coherence │
│ │ │ Handshake │
├─────────────────┼─────────────────┼─────────────────┤
│ "What I claim │ "What I │ "Can we work │
│ to be" │ actually did" │ together?" │
└─────────────────┴─────────────────┴─────────────────┘
Declaration Audit Coordination
```
### Alignment Card
A structured declaration of an agent's alignment posture:
```json
{
"aap_version": "0.1.0",
"agent_id": "did:web:my-agent.example.com",
"principal": {
"type": "human",
"relationship": "delegated_authority"
},
"values": {
"declared": ["principal_benefit", "transparency", "minimal_data"],
"conflicts_with": ["deceptive_marketing", "hidden_fees"]
},
"autonomy_envelope": {
"bounded_actions": ["search", "compare", "recommend"],
"escalation_triggers": [
{
"condition": "purchase_value > 100",
"action": "escalate",
"reason": "Exceeds autonomous spending limit"
}
],
"forbidden_actions": ["share_credentials", "subscribe_to_services"]
},
"audit_commitment": {
"trace_format": "ap-trace-v1",
"retention_days": 90,
"queryable": true
}
}
```
### AP-Trace
An audit log entry recording each decision:
```json
{
"trace_id": "tr-f47ac10b-58cc-4372",
"card_id": "ac-f47ac10b-58cc-4372",
"timestamp": "2026-01-31T12:30:00Z",
"action": {
"type": "recommend",
"name": "product_recommendation",
"category": "bounded"
},
"decision": {
"alternatives_considered": [
{"option_id": "A", "score": 0.85, "flags": []},
{"option_id": "B", "score": 0.72, "flags": ["sponsored_content"]}
],
"selected": "A",
"selection_reasoning": "Highest score. Option B flagged as sponsored and deprioritized per principal_benefit value.",
"values_applied": ["principal_benefit", "transparency"]
},
"escalation": {
"evaluated": true,
"required": false,
"reason": "Recommendation only, no purchase action"
}
}
```
### Value Coherence Handshake
Pre-coordination compatibility check between agents:
```python
from aap import check_coherence
result = check_coherence(my_card, their_card, task_context)
if result.compatible:
# Proceed with coordination
proceed_with_task()
else:
# Handle conflict
print(f"Value conflict: {result.conflicts}")
# Escalate to principals or negotiate scope
```
## What AAP Does Not Do
This matters. Read it.
1. **AAP does NOT ensure alignment—it provides visibility.** An agent can produce perfect traces while acting against its principal's interests.
2. **Verified does NOT equal safe.** A verified trace means consistency with declared alignment. It doesn't mean the alignment is good or the outcome was beneficial.
3. **AP-Trace is sampled, not complete.** Traces capture decision points, not every computation. Significant reasoning may occur between traces.
4. **Value coherence is relative to declared values.** The handshake checks if declared values are compatible. It doesn't verify agents hold these values or will act on them.
5. **Tested on transformer-based agents.** Other architectures may exhibit behaviors AAP doesn't capture.
For the complete limitations disclosure, see [Section 10 of the Specification](https://docs.mnemom.ai/protocols/aap/specification#10-limitations).
## Installation
```bash
# Python
pip install agent-alignment-protocol
# TypeScript
npm install @mnemom/agent-alignment-protocol
```
## Integration
### With A2A Agents
AAP extends the A2A Agent Card with an `alignment` block:
```json
{
"name": "Shopping Assistant",
"description": "Helps users find products",
"url": "https://shopping.example.com",
"alignment": {
"$ref": "./alignment-card.json"
}
}
```
See [A2A Integration Guide](https://docs.mnemom.ai/protocols/aap/a2a-integration).
### With MCP Tools
AAP can trace tool invocations and verify they match declared alignment:
```python
from aap import mcp_traced
@mcp_traced(card_path="alignment-card.json")
def my_tool(params):
...
```
See [MCP Migration Guide](https://docs.mnemom.ai/protocols/aap/mcp-migration).
## Verification
The verification engine checks whether observed behavior matches declared alignment:
```python
from aap import verify_trace, detect_drift
# Single trace verification
result = verify_trace(trace, card)
print(f"Verified: {result.verified}, Similarity: {result.similarity_score:.2f}")
if not result.verified:
print(f"Violations: {result.violations}")
if result.warnings:
print(f"Warnings: {result.warnings}")
# Drift detection over time
alerts = detect_drift(card, recent_traces)
for alert in alerts:
print(f"Drift detected: {alert.analysis.drift_direction}")
```
**Verification checks:**
- Autonomy compliance (actions within declared bounds)
- Escalation compliance (required escalations were performed)
- Value consistency (applied values match declared values)
- Forbidden action compliance (no forbidden actions taken)
- Behavioral similarity (semantic alignment using SSM analysis)
### Action Name Matching
Bounded and forbidden action lists support flexible matching (v0.1.7+):
```json
{
"bounded_actions": [
"search",
"exec: execute shell commands",
"cron: manage scheduled patrol jobs"
]
}
```
- **Exact match**: `"search"` matches action name `"search"`
- **Colon-prefix match**: `"exec: execute shell commands"` matches action name `"exec"`
- **Compound actions**: action name `"exec, read"` matches when *each* component is in the bounded list
This allows descriptive entries in alignment cards while keeping verification flexible.
**Similarity scoring:** Each verification returns a `similarity_score` (0.0-1.0) measuring semantic similarity between the trace and declared alignment. If a trace passes structural checks but has `similarity_score < 0.50`, a `low_behavioral_similarity` warning is generated.
## Try It
**[Interactive Playground](https://mnemom.github.io/aap/playground/)** — Verify traces in your browser with SSM visualization.
- Paste your Alignment Card and AP-Trace
- See verification results with similarity scoring
- Visualize behavioral patterns with SSM heatmaps
- Adjust thresholds in real-time
No server required — runs entirely client-side via WebAssembly.
## Documentation
| Document | Description |
|----------|-------------|
| [**Specification**](https://docs.mnemom.ai/protocols/aap/specification) | Full protocol specification (IETF-style) |
| [**Quick Start**](https://docs.mnemom.ai/protocols/aap/quickstart) | Zero to compliant in 5 minutes |
| [**Limitations**](https://docs.mnemom.ai/protocols/aap/limitations) | What AAP guarantees and doesn't |
| [**Security**](https://docs.mnemom.ai/protocols/aap/security) | Threat model and security considerations |
| [**Calibration**](https://docs.mnemom.ai/protocols/aap/calibration) | How verification thresholds were derived |
## Examples
| Example | Description |
|---------|-------------|
| [`simple-agent/`](examples/simple-agent/) | Minimal AAP implementation |
| [`a2a-integration/`](examples/a2a-integration/) | A2A agent with AAP (Python + TypeScript) |
| [`mcp-integration/`](examples/mcp-integration/) | MCP tools with alignment |
| [`alignment-failure/`](examples/alignment-failure/) | Deliberate failure for testing |
## Status
**Current Version**: 0.1.8
| Component | Status |
|-----------|--------|
| Specification | ✅ Complete |
| JSON Schemas | ✅ Complete |
| Python SDK | ✅ Complete |
| TypeScript SDK | ✅ Complete |
| Verification Engine | ✅ Complete (with similarity scoring) |
| SSM Visualization | ✅ Complete |
| Interactive Playground | ✅ Complete |
## API Reference
```python
# Core API
from aap import (
verify_trace, # Verify single trace against card → VerificationResult
check_coherence, # Check value compatibility between agents → CoherenceResult
detect_drift, # Detect behavioral drift over time → list[DriftAlert]
trace_decision, # Decorator for automatic AP-Trace generation
mcp_traced, # Decorator for MCP tool tracing
)
# Models
from aap import (
AlignmentCard,
APTrace,
VerificationResult, # .verified, .similarity_score, .violations, .warnings
CoherenceResult, # .compatible, .score, .value_alignment
DriftAlert, # .analysis.similarity_score, .analysis.drift_direction
)
# CLI
# aap init [--values VALUES] [--output FILE]
# aap verify --card CARD --trace TRACE → Shows [similarity: X.XX]
# aap check-coherence --my-card MINE --their-card THEIRS
# aap drift --card CARD --traces TRACES_DIR → Uses SSM analysis
```
## Standards & Compliance
AAP aligns with and supports compliance for the following international standards and regulatory frameworks:
| Standard | Relevance to AAP |
|----------|-----------------|
| **[ISO/IEC 42001:2023](https://www.iso.org/standard/42001)** — AI Management Systems | Alignment Card provides the structured AI system documentation required by 42001 management systems |
| **[ISO/IEC 42005:2025](https://www.iso.org/standard/42005)** — AI System Impact Assessment | AP-Trace and drift detection support ongoing impact assessment and monitoring |
| **[IEEE 7001-2021](https://standards.ieee.org/ieee/7001/6929/)** — Transparency of Autonomous Systems | AAP's core design goal — making agent decisions observable — directly implements IEEE 7001 transparency requirements |
| **[IEEE 3152-2024](https://standards.ieee.org/ieee/3152/11718/)** — Transparent Human and Machine Agency Identification | Alignment Card `agent_id`, `principal` block, and relationship types map to IEEE 3152 agency identification |
| **[Singapore IMDA Model AI Governance Framework for Agentic AI](https://www.imda.gov.sg/-/media/imda/files/about/emerging-tech-and-research/artificial-intelligence/mgf-for-agentic-ai.pdf)** (Jan 2026) | Alignment Card + Value Coherence Handshake address IMDA's agentic AI governance principles for multi-agent coordination |
| **[EU AI Act Article 50](https://artificialintelligenceact.eu/article/50/)** — Transparency Obligations (enforcement Aug 2026) | Alignment Card `principal` + disclosure fields, AP-Trace structured audit trails, and `audit_commitment.retention_days` support Article 50 compliance. See [EU AI Act Compliance Guide](https://docs.mnemom.ai/guides/eu-compliance) |
## Contributing
We welcome contributions. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
Key areas where we need help:
- SDK implementations in other languages
- Integration examples with popular agent frameworks
- Test vectors for edge cases
- Documentation improvements
## License
Apache 2.0. See [LICENSE](LICENSE) for details.
---
*Agent Alignment Protocol — Making agent alignment observable.*
| text/markdown | null | "Mnemom.ai" <dev@mnemom.ai> | null | null | null | a2a, agents, ai, alignment, audit, mcp, protocol, transparency | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software 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 :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"click>=8.0",
"jsonschema>=4.0",
"pydantic>=2.0",
"mypy>=1.8; extra == \"dev\"",
"pre-commit>=3.6; extra == \"dev\"",
"pytest-asyncio>=0.23; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.2; extra == \"dev\"",
"mkdocs-material>=9.5; extra == \"docs\"",
"mkdocs>=1.5; extra == \"docs\"",
"mkdocstrings[python]>=0.24; extra == \"docs\""
] | [] | [] | [] | [
"Homepage, https://github.com/mnemom/aap",
"Documentation, https://github.com/mnemom/aap#readme",
"Repository, https://github.com/mnemom/aap.git",
"Issues, https://github.com/mnemom/aap/issues",
"Changelog, https://github.com/mnemom/aap/blob/main/CHANGELOG.md"
] | twine/6.2.0 CPython/3.12.12 | 2026-02-21T04:13:00.880108 | agent_alignment_protocol-0.2.0.tar.gz | 54,526 | 98/be/9af8bcb13ebc8a4842f3fb3a630c9403a085931e63682b02ae58432c5470/agent_alignment_protocol-0.2.0.tar.gz | source | sdist | null | false | ead9f2d5e4ac8030e577ea6bd877ac80 | ddbfd043827452ce69ebbc98a054cbabab0bbe5b43e66831dc51cf48750d4914 | 98be9af8bcb13ebc8a4842f3fb3a630c9403a085931e63682b02ae58432c5470 | Apache-2.0 | [
"LICENSE"
] | 235 |
2.4 | pulumi-keycloak | 6.10.0 | A Pulumi package for creating and managing keycloak cloud resources. | [](https://github.com/pulumi/pulumi-keycloak/actions)
[](https://slack.pulumi.com)
[](https://www.npmjs.com/package/@pulumi/keycloak)
[](https://pypi.org/project/pulumi-keycloak)
[](https://badge.fury.io/nu/pulumi.keycloak)
[](https://pkg.go.dev/github.com/pulumi/pulumi-keycloak/sdk/v5/go)
[](https://github.com/pulumi/pulumi-keycloak/blob/master/LICENSE)
# Keycloak Resource Provider
The Keycloak resource provider for Pulumi lets you manage Keycloak resources in your cloud programs. To use
this package, please [install the Pulumi CLI first](https://www.pulumi.com/docs/reference/cli/).
## Installing
This package is available in many languages in the standard packaging formats.
### Node.js (Java/TypeScript)
To use from JavaScript or TypeScript in Node.js, install using either `npm`:
$ npm install @pulumi/keycloak
or `yarn`:
$ yarn add @pulumi/keycloak
### Python
To use from Python, install using `pip`:
$ pip install pulumi_keycloak
### Go
To use from Go, use `go get` to grab the latest version of the library
$ go get github.com/pulumi/pulumi-keycloak/sdk/v6
### .NET
To use from .NET, install using `dotnet add package`:
$ dotnet add package Pulumi.Keycloak
## Configuration
The following configuration points are available:
- `keycloak:clientId` - (Required) The client_id for the client that was created in the "Keycloak Setup" section.
Use the admin-cli client if you are using the password grant. Defaults to the environment variable `KEYCLOAK_CLIENT_ID`.
- `keycloak:url` - (Required) - The URL of the Keycloak instance, before /auth/admin. Defaults to the environment
variable `KEYCLOAK_URL`.
- `keycloak:clientSecret` - (Optional) The secret for the client used by the provider for authentication via the client
credentials grant. This can be found or changed using the "Credentials" tab in the client settings. Defaults to the
environment variable `KEYCLOAK_CLIENT_SECRET`. This attribute is required when using the client credentials grant,
and cannot be set when using the password grant.
- `keycloak:username`- (Optional) The username of the user used by the provider for authentication via the password grant.
Defaults to environment variable `KEYCLOAK_USER`. This attribute is required when using the password grant, and cannot
be set when using the client credentials grant.
- `keycloak:password`- (Optional) The password of the user used by the provider for authentication via the password grant. Defaults to
environment variable `KEYCLOAK_PASSWORD`. This attribute is required when using the password grant, and cannot be set when
using the client credentials grant.
- `keycloak:realm` - (Optional) The realm used by the provider for authentication. Defaults to environment variable
`KEYCLOAK_REALM`, or `master` if the environment variable is not specified.
- `keycloak:initialLogin` - (Optional) Optionally avoid Keycloak login during provider setup, for when Keycloak itself
is being provisioned by terraform. Defaults to `true`, which is the original method.
- `keycloak:clientTimeout` - (Optional) Sets the timeout of the client when addressing Keycloak, in seconds. Defaults to `5`.
## Reference
For further information, please visit [the Keycloak provider docs](https://www.pulumi.com/docs/intro/cloud-providers/keycloak) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/keycloak).
| text/markdown | null | null | null | null | Apache-2.0 | pulumi, keycloak | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"parver>=0.2.1",
"pulumi<4.0.0,>=3.165.0",
"semver>=2.8.1",
"typing-extensions<5,>=4.11; python_version < \"3.11\""
] | [] | [] | [] | [
"Homepage, https://pulumi.io",
"Repository, https://github.com/pulumi/pulumi-keycloak"
] | twine/6.2.0 CPython/3.11.8 | 2026-02-21T04:12:45.961709 | pulumi_keycloak-6.10.0.tar.gz | 306,601 | 05/36/0e0edc0678e9b0cdc2e3ab8f88d58ca028ae6857de45036bd2a8ad6f9855/pulumi_keycloak-6.10.0.tar.gz | source | sdist | null | false | b26a5820bcc1222aa94ebced349da2b4 | de8371f33a4075d5d218f57f667d20d25d384a8196f5a11c48e89a07b8fc3d64 | 05360e0edc0678e9b0cdc2e3ab8f88d58ca028ae6857de45036bd2a8ad6f9855 | null | [] | 244 |
2.4 | h4ckath0n | 0.1.9.dev20260221 | Ship hackathon products fast with secure-by-default auth, RBAC, PostgreSQL readiness, and built-in LLM tooling. | # h4ckath0n
Ship hackathon products fast with a secure FastAPI bootstrap and passkey-first authentication.
## What you get
- FastAPI app factory with passkey routes mounted by default
- Device signed ES256 JWT authentication and server-side RBAC (user, admin, scopes)
- SQLAlchemy 2.x models with automatic table creation on startup
- LLM wrapper around the OpenAI SDK with timeouts and retries
- Optional password auth extra for email and password flows
- Optional Redis extra that only adds the dependency, no integration is provided yet
- Trace ID middleware and LangSmith environment wiring via `init_observability`
- Full stack scaffold CLI that produces an API and web template
## Installation
### Recommended (uv)
```bash
uv add h4ckath0n
```
Optional extras:
```bash
uv add "h4ckath0n[password]" # Argon2 based password auth
uv add "h4ckath0n[redis]" # Redis dependency only
```
### pip
```bash
pip install h4ckath0n
```
## Scaffold a full stack project
```bash
npx h4ckath0n my-app
```
## Quickstart
```python
from h4ckath0n import create_app
app = create_app()
```
Run:
```bash
uv run uvicorn your_module:app --reload
```
## OpenAPI docs
- Interactive docs live at `/docs` when the app is running.
- Public routes like passkey start and finish work without auth.
- Protected routes require an `Authorization: Bearer <device_jwt>` header that the web
template can mint after login.
## Auth model
### Passkeys by default
The default authentication path uses passkeys (WebAuthn). The core flows are:
1. `POST /auth/passkey/register/start` and `POST /auth/passkey/register/finish`
2. `POST /auth/passkey/login/start` and `POST /auth/passkey/login/finish`
3. `POST /auth/passkey/add/start` and `POST /auth/passkey/add/finish` for adding devices
4. `GET /auth/passkeys` and `POST /auth/passkeys/{key_id}/revoke` for management
### Device signed JWTs
After login or registration, the client binds a device key and mints short lived ES256
JWTs. The server uses the `kid` header to load the device public key and verifies the
signature and `aud` claim. JWTs contain only identity and time claims, no roles or
scopes.
### ID scheme
- User IDs are 32 characters and start with `u`
- Passkey IDs are 32 characters and start with `k`
- Device IDs are 32 characters and start with `d`
- Password reset tokens use UUID hex, not the base32 scheme
## Secure endpoint protection
```python
from h4ckath0n import create_app
from h4ckath0n.auth import require_user
app = create_app()
@app.get("/me")
def me(user=require_user()):
return {"id": user.id, "role": user.role}
```
Admin only endpoint:
```python
from h4ckath0n.auth import require_admin
@app.get("/admin/dashboard")
def admin_dashboard(user=require_admin()):
return {"ok": True}
```
Scoped permissions:
```python
from h4ckath0n.auth import require_scopes
@app.post("/billing/refund")
def refund(user=require_scopes("billing:refund")):
return {"status": "queued"}
```
## Password auth (optional)
Password routes mount only when the password extra is installed and
`H4CKATH0N_PASSWORD_AUTH_ENABLED=true`.
- `POST /auth/register`
- `POST /auth/login`
- `POST /auth/password-reset/request`
- `POST /auth/password-reset/confirm`
Password auth is only an identity bootstrap. It binds a device key but does not return
access tokens, refresh tokens, or cookies.
## Configuration
All settings use the `H4CKATH0N_` prefix unless noted.
| Variable | Default | Description |
|---|---|---|
| `H4CKATH0N_ENV` | `development` | `development` or `production` |
| `H4CKATH0N_DATABASE_URL` | `sqlite:///./h4ckath0n.db` | SQLAlchemy connection string |
| `H4CKATH0N_AUTO_UPGRADE` | `false` | Auto-run packaged DB migrations to head on startup |
| `H4CKATH0N_RP_ID` | `localhost` in development | WebAuthn relying party ID, required in production |
| `H4CKATH0N_ORIGIN` | `http://localhost:8000` in development | WebAuthn origin, required in production |
| `H4CKATH0N_WEBAUTHN_TTL_SECONDS` | `300` | WebAuthn challenge TTL in seconds |
| `H4CKATH0N_USER_VERIFICATION` | `preferred` | WebAuthn user verification requirement |
| `H4CKATH0N_ATTESTATION` | `none` | WebAuthn attestation preference |
| `H4CKATH0N_PASSWORD_AUTH_ENABLED` | `false` | Enable password routes when the extra is installed |
| `H4CKATH0N_PASSWORD_RESET_EXPIRE_MINUTES` | `30` | Password reset token expiry in minutes |
| `H4CKATH0N_BOOTSTRAP_ADMIN_EMAILS` | `[]` | JSON list of emails that become admin on password signup |
| `H4CKATH0N_FIRST_USER_IS_ADMIN` | `false` | First password signup becomes admin |
| `OPENAI_API_KEY` | empty | OpenAI API key for the LLM wrapper |
| `H4CKATH0N_OPENAI_API_KEY` | empty | Alternate OpenAI API key for the LLM wrapper |
In development, missing `RP_ID` and `ORIGIN` fall back to localhost defaults with
warnings. In production, missing values raise a runtime error when passkey flows start.
## Postgres readiness and migrations
Set a Postgres database URL to run against Postgres:
```
H4CKATH0N_DATABASE_URL=postgresql+psycopg://user:pass@host:5432/dbname
```
`create_app()` calls `Base.metadata.create_all` on startup.
h4ckath0n also ships an operator CLI and packaged Alembic migrations:
```bash
h4ckath0n db ping
h4ckath0n db migrate upgrade --to head --yes
```
If startup or `db ping` reports that the database schema is behind, run:
```bash
h4ckath0n db migrate upgrade --to head --yes
```
If startup or `db ping` reports that the database was initialized without Alembic versioning,
run:
```bash
h4ckath0n db migrate stamp --to <baseline> --yes
h4ckath0n db migrate upgrade --to head --yes
```
For legacy `create_all` deployments in current releases, use `<baseline>=head`.
## LLM usage
```python
from h4ckath0n.llm import llm
client = llm()
resp = client.chat(
system="You are a helpful assistant.",
user="Summarize this in one sentence: ...",
)
print(resp.text)
```
The wrapper raises a `RuntimeError` if no API key is configured.
## Observability
`init_observability(app)` adds an `X-Trace-Id` header to responses and can set
LangSmith environment variables if `ObservabilitySettings.langsmith_tracing` is true.
It does not instrument FastAPI, LangChain, or OpenAI calls by itself.
```python
from h4ckath0n import create_app
from h4ckath0n.obs import ObservabilitySettings, init_observability
app = create_app()
init_observability(app, ObservabilitySettings(langsmith_tracing=True))
```
## Compatibility and operational notes
- Passkeys require HTTPS in production. `localhost` is allowed for development.
- `H4CKATH0N_RP_ID` must match your production domain and `H4CKATH0N_ORIGIN` must
include the scheme and host.
- The last active passkey cannot be revoked. Add a second passkey first.
## Development
```bash
git clone https://github.com/BTreeMap/h4ckath0n.git
cd h4ckath0n
uv sync --locked --all-extras
```
Quality gates:
```bash
uv run --locked ruff format --check .
uv run --locked ruff check .
uv run --locked mypy src
uv run --locked pytest -v
```
## License
MIT. See `LICENSE`.
| text/markdown | null | multiset <h4ckath0n@oss.joefang.org> | null | null | MIT | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"aiosqlite>=0.22.1",
"alembic>=1.14",
"asyncpg>=0.31.0",
"cryptography>=46.0.5",
"fastapi>=0.115.0",
"httpx>=0.28",
"langchain-core>=0.3",
"langchain-openai>=0.3",
"langchain>=0.3",
"langgraph>=0.2",
"langsmith>=0.2",
"openai[aiohttp]>=1.60",
"psycopg[binary]>=3.2",
"pydantic-settings>=2.7",
"pydantic[email]>=2.10",
"pyjwt[crypto]>=2.9",
"sqlalchemy>=2.0",
"sse-starlette>=2.0",
"uvicorn[standard]>=0.34.0",
"webauthn>=2.7",
"argon2-cffi>=23.1; extra == \"password\"",
"redis>=5.0; extra == \"redis\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:11:56.969091 | h4ckath0n-0.1.9.dev20260221.tar.gz | 362,882 | a7/b4/ecb4262bbe2685e7152fc3ee70b1208502a723a27da8f4eb9ceba20f146e/h4ckath0n-0.1.9.dev20260221.tar.gz | source | sdist | null | false | bbc88e3075d8f34c267f31250eb5b6de | 78100b532aba07c828f6ca9619de750c0e586f51214d2e0c115bae4e535e648f | a7b4ecb4262bbe2685e7152fc3ee70b1208502a723a27da8f4eb9ceba20f146e | null | [
"LICENSE"
] | 204 |
2.4 | mimir-client | 5.0.4 | Official Python client for the Mímir Knowledge Graph API | # mimir-client
Official Python client for the [Mímir Knowledge Graph API](https://github.com/dawsonlp/mimir).
## Installation
```bash
pip install mimir-client
```
## Quick Start
```python
import asyncio
from mimir_client import MimirClient
async def main():
async with MimirClient(api_url="http://localhost:38000", tenant_id=1) as client:
# Health check
healthy = await client.is_healthy()
print(f"API healthy: {healthy}")
# Create an artifact
artifact = await client.create_artifact(
"document",
title="Architecture Overview",
content="This document describes the system architecture.",
metadata={"author": "team-lead"},
)
print(f"Created: {artifact.id} — {artifact.title}")
# Search
results = await client.search(query="architecture")
for r in results.results:
print(f" [{r.score:.2f}] {r.artifact.title}")
asyncio.run(main())
```
## Configuration
### Direct instantiation
```python
client = MimirClient(
api_url="http://localhost:38000",
tenant_id=1,
timeout=30.0,
)
```
### From environment variables
```python
from mimir_client import MimirClient, get_settings
# Reads MIMIR_API_URL, MIMIR_TENANT_ID, MIMIR_TIMEOUT from env / .env
settings = get_settings()
client = MimirClient.from_settings(settings)
```
| Environment Variable | Default | Description |
|---------------------|---------|-------------|
| `MIMIR_API_URL` | `http://localhost:38000` | Mímir API base URL |
| `MIMIR_TENANT_ID` | `None` | Default tenant ID |
| `MIMIR_TIMEOUT` | `30.0` | Request timeout (seconds) |
## API Coverage
All Mímir v5 REST endpoints are covered:
| Resource | Methods |
|----------|---------|
| **Tenants** | `create_tenant`, `get_tenant`, `get_tenant_by_shortname`, `list_tenants`, `update_tenant`, `delete_tenant`, `ensure_tenant` |
| **Artifact Types** | `create_artifact_type`, `get_artifact_type`, `list_artifact_types`, `update_artifact_type`, `ensure_artifact_type` |
| **Artifacts** | `create_artifact`, `get_artifact`, `list_artifacts`, `get_children` |
| **Relation Types** | `create_relation_type`, `get_relation_type`, `list_relation_types`, `update_relation_type`, `get_inverse_relation_type`, `ensure_relation_type` |
| **Relations** | `create_relation`, `get_relation`, `list_relations`, `get_artifact_relations` |
| **Embedding Types** | `create_embedding_type`, `get_embedding_type`, `list_embedding_types`, `delete_embedding_type`, `ensure_embedding_type` |
| **Embeddings** | `create_embedding`, `get_embedding`, `list_embeddings` |
| **Search** | `search` (unified), `search_fulltext` |
| **Context** | `get_context` |
| **Provenance** | `list_provenance_by_artifact`, `list_provenance_by_source` |
| **Health** | `health`, `is_healthy` |
## Typed Responses
All methods return Pydantic models with full type information:
```python
artifact = await client.create_artifact("document", title="Test")
print(artifact.id) # UUID
print(artifact.title) # str | None
print(artifact.created_at) # datetime
```
## Error Handling
Errors are mapped to typed exceptions:
```python
from mimir_client import MimirNotFoundError, MimirConflictError
try:
artifact = await client.get_artifact("nonexistent-uuid")
except MimirNotFoundError:
print("Artifact not found")
try:
await client.create_relation(src_id, tgt_id, "derived_from")
except MimirConflictError:
print("Relation already exists")
```
| HTTP Status | Exception |
|------------|-----------|
| Connection failure | `MimirConnectionError` |
| 404 | `MimirNotFoundError` |
| 409 | `MimirConflictError` |
| 422 | `MimirValidationError` |
| 5xx | `MimirServerError` |
| Other 4xx | `MimirError` |
## Convenience Methods
`ensure_*` methods are idempotent — they return existing resources or create new ones:
```python
# Safe to call repeatedly — no-op if already exists
tenant = await client.ensure_tenant("dev", "Development")
await client.ensure_artifact_type("document", "Document", category="content")
await client.ensure_relation_type("derived_from", "Derived From", inverse_code="source_of")
await client.ensure_embedding_type("nomic", provider="ollama", dimensions=768)
```
## Scope
This client is a **thin HTTP wrapper**. It does NOT include:
- Embedding generation (use [`mimir-semantic`](../../semantic/) for Ollama/OpenAI/Voyage integration)
- Token budgeting or RAG policies
- Graph traversal algorithms
- Batch operations
## Requirements
- Python >= 3.11
- httpx
- pydantic >= 2.0
- pydantic-settings >= 2.0
## License
MIT
| text/markdown | Development Team | null | null | null | MIT | null | [
"Development Status :: 3 - Alpha",
"Framework :: AsyncIO",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Typing :: Typed"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"httpx>=0.27",
"pydantic-settings>=2.0",
"pydantic>=2.0",
"black; extra == \"dev\"",
"mypy; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pytest-asyncio; extra == \"dev\"",
"respx; extra == \"dev\"",
"ruff; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/dawsonlp/mimir",
"Documentation, https://github.com/dawsonlp/mimir/tree/main/clients/python",
"Repository, https://github.com/dawsonlp/mimir",
"Issues, https://github.com/dawsonlp/mimir/issues"
] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-21T04:09:25.198493 | mimir_client-5.0.4.tar.gz | 16,118 | d0/82/844330e5023111b9fde5aa2e49b3b6de6c67d3913e2ec45193eb58004929/mimir_client-5.0.4.tar.gz | source | sdist | null | false | 7e3c55205c1309e8c677debe460bd8ac | 4af66a08d9162f2a448ff66c1b07082508011e96adc2a147280f4b953af987f9 | d082844330e5023111b9fde5aa2e49b3b6de6c67d3913e2ec45193eb58004929 | null | [
"LICENSE"
] | 235 |
2.4 | crystalwindow | 6.0.9 | A Tkinter powered window + GUI toolkit made by Crystal (ME)! Easier apps, smoother UI and all-in-one helpers!, Gui, Buttons, FileHelper, Sprites, Animations, Colors, Math, Gravity, Camera, 3D and more! | # CRYSTALWINDOW!!!
A tiny but mighty Tkinter framework that gives u a full window system, GUI magic, physics, and file power — all packed into one clean lil module. made by crystal
No setup pain. No folder chaos.
Just import it. Boom. Instant game window. 🎮
# Quick Start
pip install crystalwindow
then make a new .py file:
from crystalwindow import Window # imports everything from crystalwindow (in this case its Window)
win = Window(800, 600, "Crystal Demo") # setup: Window(width, height, name, icon=MyIcon.ico)
win.run() # runs the window loop
win.quit() # closes it (for RAM n CPU)
Run it. and boom, instant working window.
Yes, THAT easy.
# Easy crystalwindow window + Gui + Text file:
from crystalwindow import *
win = Window(800, 600, "CrystalWindowLib Mega Sandbox")
gui = GUIManager()
toggle1 = Toggle((50, 50, 100, 40), value=False)
slider1 = Slider((50, 120, 200, 30), min_val=0, max_val=100, value=50)
btn1 = Button(rect=(50, 200, 150, 50), text="Click Me!", color=random_color(),
hover_color=random_color(), callback=lambda: print("Button clicked!"))
lbl1 = Label((250, 50), "Hello GUI!", color=random_color(), size=24)
gui.add(toggle1)
gui.add(slider1)
gui.add(btn1)
gui.add(lbl1)
# --- Debug Overlay ---
debug = DebugOverlay()
# --- Camera Shake ---
shake = CameraShake(intensity=20)
# --- Main loop ---
def update(win):
gui.update(win)
gui.draw(win)
# --- draw text examples ---
win.draw_text_later("Normal Text", pos=(400, 50), size=18, color=random_color())
win.draw_text_later("Bold Text", pos=(400, 80), size=20, color=random_color(), bold=True)
win.draw_text_later("Italic Text", pos=(400, 110), size=20, color=random_color(), italic=True)
win.draw_text_later("Bold + Italic", pos=(400, 140), size=22, color=random_color(), bold=True, italic=True)
# --- draw toggle/slider values ---
win.draw_text_later(f"Toggle: {toggle1.value}", pos=(50, 90), size=18)
win.draw_text_later(f"Slider: {int(slider1.value)}", pos=(50, 160), size=18)
# --- draw gradient ---
gradient_rect(win, (50, 300, 200, 100), (255,0,0), (0,0,255))
# --- screen shake example (move a rectangle with shake) ---
shake.update()
x_off, y_off = shake.offset
win.draw_rect((0,255,0), (500+x_off, 300+y_off, 100, 50))
# --- draw random name + color ---
win.draw_text_later(f"Random Name: {random_name()}", pos=(50, 420), size=20, color=random_color())
# --- debug overlay ---
debug.draw(win, fps=int(win.clock.get_fps()))
win.run(update)
win.quit()
And now thats how you use it!
# Current Variables.
# Whats Inside
Built-in window manager
Built-in GUI (buttons, sliders, toggles, labels)
Built-in gravity + physics engine
Tilemap system (place & save blocks!)
Image loader (with default base64 logo)
Safe startup (works even inside PyInstaller)
Mathematics Handler
Works offline
Minimal syntax
Full debug overlay
# Window System
from crystalwindow import *
win = Window(800, 600, "My Game", icon="MyIcon.png")
def loop(win):
win.fill((10, 10, 30))
# draw or update stuff here
win.run(loop)
win.quit()
# Features
* handles events
* tracks keys + mouse
* supports fullscreen
* safe to close anytime
# Player Example
player = Player(100, 100)
def loop(win):
player.update(win.keys)
player.draw(win.screen)
move(dx, dy) -> moves player
take_damage(x) -> takes damage
heal(x) -> heals
draw(surface) -> renders sprite
# TileMap
tilemap = TileMap(32)
tilemap.add_tile(5, 5, "grass")
tilemap.save("level.json")
add_tile(x, y, type)
remove_tile(x, y)
draw(surface)
save(file) / load(file)
# GUI System
btn = Button(20, 20, 120, 40, "Click Me!", lambda: print("yo"))
gui = GUIManager()
gui.add(btn)
Use built-in stuff like:
Button(x, y, w, h, text, onclick)
Label(x, y, text)
Toggle(x, y, w, h, text, default=False)
Slider(x, y, w, min, max, default)
# Gravity
g = Gravity(0.5)
g.update(player)
makes objects fall realistically. ez.
# FileHelper
save_json("data.json", {"coins": 99})
data = load_json("data.json")
Also supports:
save_pickle / load_pickle
FileDialog("save") (tkinter dialog popup)
# DrawHelper
DrawHelper.text(win.screen, "Hello!", (10,10), (255,255,255), 24)
DrawHelper.rect(win.screen, (100,0,200), (50,50,100,60))
perfect for ui & quick visuals
# Debug Tools
debug = DebugOverlay()
debug.toggle() # show or hide FPS
debug.draw(win.screen, {"hp": 100, "fps": win.clock.get_fps()})
# Mathematics
math = Mathematics()
* Current Variables
math.add(num1, num2)
math.subtract(num1, num2)
math.multiply(num1, num2)
math.divide(num1, num2)
# Example Game
from crystalwindow import *
win = Window(800, 600, "My Cool Game")
player = Player(100, 100)
gravity = Gravity()
def update(win):
win.fill((25, 25, 40))
player.update(win.keys)
gravity.update(player)
player.draw(win.screen)
win.run(update)
win.quit()
# Default Logo
There is a lil encoded PNG inside the file called:
DEFAULT_LOGO_BASE64
Its used when no icon is given.
Set ur own like:
Window(800, 600, "My Window", icon="MyIcon.png")
or do whatever you want.. i guess.
# Example Integration
from crystalwindow import Window
win = Window(800, 600, "My Window", icon="MyIcon.png")
while win.running:
win.check_events()
win.fill((10, 10, 20))
win.run()
win.quit()
# Credits
Made by: CrystalBallyHereXD
Framework: CrystalWindow
Powered by: Tkinter and Python
License: Free to use, modify, and vibe with it!
| text/markdown | CrystalBallyHereXD | mavilla.519@gmail.com | null | null | null | tkinter gui window toolkit easy crystalwindow crystal cw player moveable easygui python py file math gravity hex color | [
"Programming Language :: Python :: 3",
"Operating System :: OS Independent",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: MIT License"
] | [] | https://pypi.org/project/crystalwindow/ | null | >=3.6 | [] | [] | [] | [
"requests",
"packaging",
"pillow"
] | [] | [] | [] | [
"Homepage, https://github.com/CrystalBallyHereXD/crystalwindow",
"YouTube, https://www.Youtube.com/@CrystalBallyHereXD",
"PiWheels, https://www.piwheels.org/project/crystalwindow/"
] | twine/6.2.0 CPython/3.11.2 | 2026-02-21T04:08:16.991974 | crystalwindow-6.0.9.tar.gz | 73,313 | a9/b2/a9a7fdd0c4c3eb7ff3babc284b447169ee24d054b3945000334938b1c450/crystalwindow-6.0.9.tar.gz | source | sdist | null | false | 2772163a8474e9b3e0cad664f3ea2b7d | 3a02e72283312b586603674487d976b2e361d8920bacb6c485e8fe49dae93fa1 | a9b2a9a7fdd0c4c3eb7ff3babc284b447169ee24d054b3945000334938b1c450 | null | [
"LICENSE"
] | 255 |
2.4 | superdoc-sdk | 1.0.0a16 | SuperDoc SDK (CLI-backed) | # superdoc-sdk
Programmatic SDK for deterministic DOCX operations through SuperDoc's Document API.
## Install
```bash
pip install superdoc-sdk
```
The package installs a platform-specific CLI companion package automatically via [PEP 508 environment markers](https://peps.python.org/pep-0508/). Supported platforms:
| Platform | Architecture |
|----------|-------------|
| macOS | Apple Silicon (arm64), Intel (x64) |
| Linux | x64, ARM64 |
| Windows | x64 |
## Quick start
```python
import asyncio
from superdoc import AsyncSuperDocClient
async def main():
client = AsyncSuperDocClient()
await client.doc.open({"doc": "./contract.docx"})
info = await client.doc.info({})
print(info["counts"])
results = await client.doc.find({"query": {"kind": "text", "pattern": "termination"}})
target = results["context"][0]["textRanges"][0]
await client.doc.replace({"target": target, "text": "expiration"})
await client.doc.save({"inPlace": True})
await client.doc.close({})
asyncio.run(main())
```
## API
### Client
```python
from superdoc import SuperDocClient
client = SuperDocClient()
```
All document operations are on `client.doc`:
```python
await client.doc.open(params)
await client.doc.find(params)
await client.doc.insert(params)
# ... etc
```
### Operations
| Category | Operations |
|----------|-----------|
| **Query** | `find`, `get_node`, `get_node_by_id`, `info` |
| **Mutation** | `insert`, `replace`, `delete` |
| **Format** | `format.bold`, `format.italic`, `format.underline`, `format.strikethrough` |
| **Create** | `create.paragraph` |
| **Lists** | `lists.list`, `lists.get`, `lists.insert`, `lists.set_type`, `lists.indent`, `lists.outdent`, `lists.restart`, `lists.exit` |
| **Comments** | `comments.add`, `comments.edit`, `comments.reply`, `comments.move`, `comments.resolve`, `comments.remove`, `comments.set_internal`, `comments.set_active`, `comments.go_to`, `comments.get`, `comments.list` |
| **Track Changes** | `track_changes.list`, `track_changes.get`, `track_changes.accept`, `track_changes.reject`, `track_changes.accept_all`, `track_changes.reject_all` |
| **Lifecycle** | `open`, `save`, `close` |
| **Session** | `session.list`, `session.save`, `session.close`, `session.set_default` |
| **Introspection** | `status`, `describe`, `describe_command` |
## Troubleshooting
### Custom CLI binary
If you need to use a custom-built CLI binary (e.g. a newer version or a patched build), set the `SUPERDOC_CLI_BIN` environment variable:
```bash
export SUPERDOC_CLI_BIN=/path/to/superdoc
```
### Air-gapped / private index environments
Mirror both `superdoc-sdk` and the `superdoc-sdk-cli-*` package for your platform to your private index. For example, on macOS ARM64:
```bash
pip download superdoc-sdk superdoc-sdk-cli-darwin-arm64
# Upload both wheels to your private index
```
## Part of SuperDoc
This SDK is part of [SuperDoc](https://github.com/superdoc-dev/superdoc) — an open source document editor bringing Microsoft Word to the web.
## License
AGPL-3.0 · [Enterprise license available](https://superdoc.dev)
| text/markdown | SuperDoc | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"superdoc-sdk-cli-darwin-arm64==1.0.0a16; platform_system == \"Darwin\" and (platform_machine == \"arm64\" or platform_machine == \"aarch64\" or platform_machine == \"ARM64\")",
"superdoc-sdk-cli-darwin-x64==1.0.0a16; platform_system == \"Darwin\" and (platform_machine == \"x86_64\" or platform_machine == \"AMD64\" or platform_machine == \"amd64\")",
"superdoc-sdk-cli-linux-x64==1.0.0a16; platform_system == \"Linux\" and (platform_machine == \"x86_64\" or platform_machine == \"AMD64\" or platform_machine == \"amd64\")",
"superdoc-sdk-cli-linux-arm64==1.0.0a16; platform_system == \"Linux\" and (platform_machine == \"arm64\" or platform_machine == \"aarch64\" or platform_machine == \"ARM64\")",
"superdoc-sdk-cli-windows-x64==1.0.0a16; platform_system == \"Windows\" and (platform_machine == \"x86_64\" or platform_machine == \"AMD64\" or platform_machine == \"amd64\")"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:08:15.062916 | superdoc_sdk-1.0.0a16.tar.gz | 80,572 | a3/fc/f4898f91f8920510901625b27336eb4b03d3e8c22592fdba7a96f3d0f2ee/superdoc_sdk-1.0.0a16.tar.gz | source | sdist | null | false | 4153defc87f99abaf69d777267f46472 | 303fc84e9d94c37cdb913cf56b3773c52540051344ba3c19ef8251b4199f9879 | a3fcf4898f91f8920510901625b27336eb4b03d3e8c22592fdba7a96f3d0f2ee | AGPL-3.0 | [] | 204 |
2.4 | superdoc-sdk-cli-windows-x64 | 1.0.0a16 | SuperDoc CLI binary for Windows x64 | # superdoc-sdk-cli-windows-x64
Platform companion package for [`superdoc-sdk`](https://pypi.org/project/superdoc-sdk/).
This package is automatically installed by `superdoc-sdk` via PEP 508 environment markers — you do not need to install it manually.
For air-gapped or private index environments, mirror both `superdoc-sdk` and the `superdoc-sdk-cli-*` package for your platform.
| text/markdown | SuperDoc | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:08:05.938103 | superdoc_sdk_cli_windows_x64-1.0.0a16-py3-none-any.whl | 42,628,420 | 22/ca/bc6d087054ad218cbb5ed777b1533af26893dbcf362d17b2db431bce2f1c/superdoc_sdk_cli_windows_x64-1.0.0a16-py3-none-any.whl | py3 | bdist_wheel | null | false | ebebaffbc2789bd11458d741d65f3ddd | d4a3a49a57284727dcb18b94e550a8c763ef316fa7a35437c8ba3bd71cbe8551 | 22cabc6d087054ad218cbb5ed777b1533af26893dbcf362d17b2db431bce2f1c | AGPL-3.0 | [] | 103 |
2.4 | superdoc-sdk-cli-linux-x64 | 1.0.0a16 | SuperDoc CLI binary for Linux x64 | # superdoc-sdk-cli-linux-x64
Platform companion package for [`superdoc-sdk`](https://pypi.org/project/superdoc-sdk/).
This package is automatically installed by `superdoc-sdk` via PEP 508 environment markers — you do not need to install it manually.
For air-gapped or private index environments, mirror both `superdoc-sdk` and the `superdoc-sdk-cli-*` package for your platform.
| text/markdown | SuperDoc | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:08:02.750289 | superdoc_sdk_cli_linux_x64-1.0.0a16-py3-none-any.whl | 40,638,943 | e4/c1/6b0b7de03763adb17041e112c2b138584d25542ee9253329199fed7b51a5/superdoc_sdk_cli_linux_x64-1.0.0a16-py3-none-any.whl | py3 | bdist_wheel | null | false | d6da8e4f46feb9a446b253f72a9babb3 | 4c0ba38d464e77282361a3d35fdface4d44e2153cb99911bb048bb68b58bccf5 | e4c16b0b7de03763adb17041e112c2b138584d25542ee9253329199fed7b51a5 | AGPL-3.0 | [] | 102 |
2.4 | superdoc-sdk-cli-linux-arm64 | 1.0.0a16 | SuperDoc CLI binary for Linux ARM64 | # superdoc-sdk-cli-linux-arm64
Platform companion package for [`superdoc-sdk`](https://pypi.org/project/superdoc-sdk/).
This package is automatically installed by `superdoc-sdk` via PEP 508 environment markers — you do not need to install it manually.
For air-gapped or private index environments, mirror both `superdoc-sdk` and the `superdoc-sdk-cli-*` package for your platform.
| text/markdown | SuperDoc | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:07:59.835774 | superdoc_sdk_cli_linux_arm64-1.0.0a16-py3-none-any.whl | 40,135,666 | e7/f2/036eba92b0a4b600253727eff35f86319fa6a7c72d112aae918d254ecc2f/superdoc_sdk_cli_linux_arm64-1.0.0a16-py3-none-any.whl | py3 | bdist_wheel | null | false | 8b543bc0215dfbe380a5bb9da1309c8b | faaee3a7fd73e84bba61af6a21dea356c0cd9e62d275bbfe7b7881720396c5ba | e7f2036eba92b0a4b600253727eff35f86319fa6a7c72d112aae918d254ecc2f | AGPL-3.0 | [] | 96 |
2.4 | superdoc-sdk-cli-darwin-x64 | 1.0.0a16 | SuperDoc CLI binary for macOS x64 (Intel) | # superdoc-sdk-cli-darwin-x64
Platform companion package for [`superdoc-sdk`](https://pypi.org/project/superdoc-sdk/).
This package is automatically installed by `superdoc-sdk` via PEP 508 environment markers — you do not need to install it manually.
For air-gapped or private index environments, mirror both `superdoc-sdk` and the `superdoc-sdk-cli-*` package for your platform.
| text/markdown | SuperDoc | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:07:56.587057 | superdoc_sdk_cli_darwin_x64-1.0.0a16-py3-none-any.whl | 26,151,224 | 0f/92/20405ad1a7fbd95cd7b48b312bc34ccb2019e830d611d1aa3af38192abd0/superdoc_sdk_cli_darwin_x64-1.0.0a16-py3-none-any.whl | py3 | bdist_wheel | null | false | a3f9d9dbdb018e4e236453754cc39898 | f0ce0a0ced7ddb0dd83d6bf869e1256869f1086dacd1a1b41b3eca6f4bb57843 | 0f9220405ad1a7fbd95cd7b48b312bc34ccb2019e830d611d1aa3af38192abd0 | AGPL-3.0 | [] | 76 |
2.4 | superdoc-sdk-cli-darwin-arm64 | 1.0.0a16 | SuperDoc CLI binary for macOS ARM64 (Apple Silicon) | # superdoc-sdk-cli-darwin-arm64
Platform companion package for [`superdoc-sdk`](https://pypi.org/project/superdoc-sdk/).
This package is automatically installed by `superdoc-sdk` via PEP 508 environment markers — you do not need to install it manually.
For air-gapped or private index environments, mirror both `superdoc-sdk` and the `superdoc-sdk-cli-*` package for your platform.
| text/markdown | SuperDoc | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:07:53.902307 | superdoc_sdk_cli_darwin_arm64-1.0.0a16-py3-none-any.whl | 23,937,000 | d2/67/39135572edb992463a8910f20b10a8786074b011afbbd5931ea955b05f76/superdoc_sdk_cli_darwin_arm64-1.0.0a16-py3-none-any.whl | py3 | bdist_wheel | null | false | ecca6e0449812c2359610623775929c4 | edd0f1f040b09f9a86ebfe9c19a357f6fcb754b86cbdcb3e7cd2b1e9a5c12698 | d26739135572edb992463a8910f20b10a8786074b011afbbd5931ea955b05f76 | AGPL-3.0 | [] | 77 |
2.4 | iara-reviewer | 1.6.0 | AI-powered code reviewer using OpenRouter LLMs | # Iara - AI Code Reviewer 🧜♀️
🇧🇷 [Leia em Português](README.pt-br.md)
Iara is an automated, project-agnostic, configurable code review tool designed to run in CI/CD pipelines or locally via CLI. It connects directly to the LLM provider of your choice — OpenRouter (free models), OpenAI, Google Gemini, or Anthropic Claude.
---
[](https://github.com/felipefernandes/iara/actions/workflows/iara-review.yml) [](https://github.com/felipefernandes/iara/actions/workflows/tests.yml) [](https://codecov.io/gh/felipefernandes/iara) [](https://pypi.org/project/iara-reviewer/) [](https://github.com/marketplace/actions/iara-code-reviewer) [](https://opensource.org/licenses/MIT)
---
## 🚀 Features
- **Agnostic**: Configure your project context (Tech Stack, Rules) via JSON.
- **Multi-Provider**: Connect directly to OpenRouter, OpenAI, Google Gemini, or Anthropic Claude.
- **Smart Fallback**: Automatically tries free models if the preferred one fails (OpenRouter only).
- **Rules-Based (Static)**: Identifies dangerous patterns instantly without spending tokens (e.g., `GetComponent` in loops in Unity).
- **LLM-Based (Intelligent)**: Uses AI to understand logic, security, and context, going beyond syntax.
- **GitHub + GitLab**: Native integration with both platforms, with automatic comments on PRs/MRs.
- **Multi-Language Reviews**: Configure the output language — reviews can be written in English, Portuguese, Spanish, French, and more.
## 🧠 Capabilities
Iara combines different types of analysis for a complete review:
| Type | What does it do? | Does Iara cover it? | How? |
| :------------------- | :------------------------------------ | :------------------ | :---------------------------------------- |
| **Static Analysis** | Finds bugs by reading code (fast). | ✅ **Yes** | Via Extensions (Regex) and LLM. |
| **Linting** | Fixes style and formatting. | ✅ **Yes** | LLM can suggest _Clean Code_. |
| **SAST** | Finds security flaws in code. | ✅ **Yes** | Primary focus on vulnerability detection. |
| **Dynamic Analysis** | Finds bugs by running the app (slow). | ❌ No | Focus on fast CI/CD (Code Review). |
### What does it detect?
1. **Unity / Game Dev**:
- Use of slow APIs (`Find`, `GetComponent`) in critical loops (`Update`).
- Excessive memory allocation (Garbage Collection).
- Excess logging (`Debug.Log`) in final builds.
2. **Security (General)**:
- Hardcoded credentials (Passwords, API Keys).
- Injection vulnerabilities (SQL, Command).
- Missing input validation.
3. **Code Quality**:
- Complex or confusing logic.
- Exception handling errors.
- Refactoring suggestions for readability.
---
## 📦 Installation and Setup
### 1. Install
```bash
pip install iara-reviewer
```
### 2. Configure (Interactive Setup)
```bash
iara init
```
The wizard guides you through **5 steps**:
1. **Language** — Choose the review output language (en, pt-br, es, fr, etc.)
2. **Provider** — Choose your LLM provider: `openrouter` (default, free), `openai`, `gemini`, or `anthropic`
3. **API Key** — Enter the key for the chosen provider (validated and saved to `~/.iara/config.json`)
4. **Project** — Name, tech stack, description
5. **Preferences** — Focus areas (Security, Performance, etc.)
Done! Project config is saved at `.iara.json`.
### 3. Use
```bash
git diff main | iara
```
### Check authentication
```bash
iara auth status
```
### Manual setup (without wizard)
Set the provider and its key via environment variables:
```bash
# OpenRouter (default — free models available)
export OPENROUTER_API_KEY="sk-or-..."
# OpenAI
export IARA_PROVIDER="openai"
export OPENAI_API_KEY="sk-..."
# Google Gemini
export IARA_PROVIDER="gemini"
export GEMINI_API_KEY="AIza..."
# Anthropic Claude
export IARA_PROVIDER="anthropic"
export ANTHROPIC_API_KEY="sk-ant-..."
```
API key resolution priority: environment variable > global config (`~/.iara/config.json`).
### From source (Development)
```bash
git clone https://github.com/felipefernandes/iara.git
cd iara
pip install -e .
```
---
## ⚙️ Project Configuration
`iara init` automatically creates `.iara.json`. You can also create it manually:
```json
{
"project": {
"name": "My Project",
"description": "Project description.",
"tech_stack": ["Python"]
},
"review": {
"focus_areas": ["Performance", "Security"],
"ignore_patterns": []
},
"model": {
"preferred": "google/gemini-2.0-flash-exp:free",
"fallback_enabled": true,
"provider": "openrouter"
},
"language": "en"
}
```
### Supported providers and example models
| Provider | `provider` value | Example models |
| :--- | :--- | :--- |
| OpenRouter (default) | `openrouter` | `google/gemini-2.0-flash-exp:free`, `meta-llama/llama-3.2-3b-instruct:free` |
| OpenAI | `openai` | `gpt-4o`, `gpt-4.5-preview`, `o1` |
| Google Gemini | `gemini` | `gemini-2.5-flash`, `gemini-2.5-pro` |
| Anthropic Claude | `anthropic` | `claude-opus-4-5-20250929`, `claude-sonnet-4-5-20250929` |
> **Note**: Smart fallback to free models is only available for OpenRouter. When using `openai`, `gemini`, or `anthropic`, set `"fallback_enabled": false`.
The `language` field controls the review output language. Supported values: `en`, `pt-br`, `es`, `fr`, `de`, `ja`, `zh`, `ko`, `ru`, or any language the LLM understands.
You can also override provider, model, and language via environment variables:
```bash
export IARA_PROVIDER="anthropic"
export IARA_MODEL="claude-sonnet-4-5-20250929"
export IARA_LANGUAGE="pt-br"
```
A ready-to-use example is available at `iara-example.json`.
---
## 🧠 Memory (RAG) [New]
Iara now supports a local **Retrieval-Augmented Generation (RAG)** system to provide context-aware reviews.
### 1. Install Dependencies
```bash
pip install iara-reviewer[rag]
# or
pip install lancedb sentence-transformers torch numpy
```
### 2. Index Your Codebase
Run this command in your project root to create the local vector index:
```bash
iara memory index
```
This will parse your code (extracting functions, classes, and calls) and store it in `.iara/data/lancedb`.
### 3. Review with Context
Just run the review command as usual. Iara will automatically use the memory to retrieve relevant context for the changed code.
```bash
git diff main | iara
```
### 4. Manage Memory
To clear the index:
```bash
iara memory clear
```
---
## 🏃 How to Use
### Via Pipe (Git Diff)
```bash
git diff main | iara
```
### Via Environment Variable
```bash
export PR_DIFF=$(git diff main)
iara
```
### Scan Mode (Static Analysis)
```bash
iara --scan ./path/to/project
```
### Forcing a Provider and Model
```bash
# Anthropic Claude
export IARA_PROVIDER="anthropic"
export ANTHROPIC_API_KEY="sk-ant-..."
export IARA_MODEL="claude-sonnet-4-5-20250929"
git diff | iara
# OpenAI GPT-4o
export IARA_PROVIDER="openai"
export OPENAI_API_KEY="sk-..."
export IARA_MODEL="gpt-4o"
git diff | iara
# Google Gemini
export IARA_PROVIDER="gemini"
export GEMINI_API_KEY="AIza..."
export IARA_MODEL="gemini-2.5-flash"
git diff | iara
```
---
## 🐙 GitHub Integration
Iara is available on the [**GitHub Marketplace**](https://github.com/marketplace/actions/iara-code-reviewer) — you can add it to your repository with just a few clicks. No Docker required! Iara runs as a lightweight **Composite Action** directly on the runner, with automatic pip caching for fast execution.
Add Iara to your GitHub repository in **2 steps**:
### 1. Configure the secret
Go to **Settings > Secrets and variables > Actions > New repository secret** and add the key for your chosen provider:
| Provider | Secret name |
| :--- | :--- |
| OpenRouter | `OPENROUTER_API_KEY` |
| OpenAI | `OPENAI_API_KEY` |
| Google Gemini | `GEMINI_API_KEY` |
| Anthropic | `ANTHROPIC_API_KEY` |
### 2. Create the workflow
Create the file `.github/workflows/iara-review.yml`.
**With OpenRouter (default, free models):**
```yaml
name: Iara Code Review
on:
pull_request:
types: [opened, synchronize]
permissions:
pull-requests: write
contents: read
jobs:
review:
runs-on: ubuntu-latest
name: AI Code Review
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Run Iara Code Review
uses: felipefernandes/iara@main
with:
openrouter_api_key: ${{ secrets.OPENROUTER_API_KEY }}
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```
**With Anthropic Claude:**
```yaml
- name: Run Iara Code Review
uses: felipefernandes/iara@main
with:
provider: anthropic
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
model: "claude-sonnet-4-5-20250929"
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```
**With OpenAI:**
```yaml
- name: Run Iara Code Review
uses: felipefernandes/iara@main
with:
provider: openai
openai_api_key: ${{ secrets.OPENAI_API_KEY }}
model: "gpt-4o"
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```
**With Google Gemini:**
```yaml
- name: Run Iara Code Review
uses: felipefernandes/iara@main
with:
provider: gemini
gemini_api_key: ${{ secrets.GEMINI_API_KEY }}
model: "gemini-2.5-flash"
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```
Iara will automatically:
- Review the Pull Request diff
- Post a comment with the review result
### All available inputs
```yaml
- uses: felipefernandes/iara@main
with:
provider: "openrouter" # openrouter (default), openai, gemini, anthropic
openrouter_api_key: ${{ secrets.OPENROUTER_API_KEY }} # when provider=openrouter
openai_api_key: ${{ secrets.OPENAI_API_KEY }} # when provider=openai
gemini_api_key: ${{ secrets.GEMINI_API_KEY }} # when provider=gemini
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }} # when provider=anthropic
model: "google/gemini-2.0-flash-exp:free" # override model
config_path: ".iara.json" # config path (default: .iara.json)
post_comment: "true" # post comment on PR (default: true)
language: "en" # review language
index_codebase: "true" # enable RAG memory (default: false)
```
---
## 🦊 GitLab Integration
### 1. Configure variables
Go to **Settings > CI/CD > Variables** and add:
- The key for your provider (e.g., `OPENROUTER_API_KEY`, `ANTHROPIC_API_KEY`, etc.)
- `IARA_PROVIDER`: the provider name (e.g., `anthropic`) — omit for OpenRouter default
- `GITLAB_TOKEN`: Personal/Project Access Token with `api` scope (required for MR comments)
### 2. Add to `.gitlab-ci.yml`
```yaml
stages:
- review
iara_code_review:
stage: review
image: python:3.11-slim
script:
- apt-get update && apt-get install -y --no-install-recommends git curl
- pip install iara-reviewer
- git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
- export PR_DIFF=$(git diff origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME...$CI_COMMIT_SHA)
- REVIEW=$(iara 2>/tmp/iara_stderr.txt) || true
- echo "$REVIEW"
- |
if [ -n "$REVIEW" ] && [ -n "$GITLAB_TOKEN" ]; then
PAYLOAD=$(python3 -c "
import sys, json
review = '''$REVIEW'''
body = '## 🧜♀️ Iara Code Review\n\n' + review + '\n\n---\n*Reviewed by Iara - AI Code Reviewer*'
print(json.dumps({'body': body}))
")
curl -s -X POST \
-H "PRIVATE-TOKEN: $GITLAB_TOKEN" \
-H "Content-Type: application/json" \
-d "$PAYLOAD" \
"${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/merge_requests/${CI_MERGE_REQUEST_IID}/notes"
fi
allow_failure: true
rules:
- if: $CI_PIPELINE_SOURCE == "merge_request_event"
```
Iara will automatically:
- Review the Merge Request diff
- Post a comment with the review result on the MR
A complete template is available at `gitlab-ci.yml`.
---
## 🔧 Any CI (Jenkins, CircleCI, etc.)
```bash
pip install iara-reviewer
# OpenRouter (default)
export OPENROUTER_API_KEY="sk-or-..."
git diff main...HEAD | iara
# Anthropic Claude
export IARA_PROVIDER="anthropic"
export ANTHROPIC_API_KEY="sk-ant-..."
export IARA_MODEL="claude-sonnet-4-5-20250929"
git diff main...HEAD | iara
```
---
## 🧪 Tests
```bash
python -m unittest discover tests
```
## 📜 License
MIT
| text/markdown | Felipe Fernandes | null | null | null | null | code-review, ai, llm, openrouter, github, gitlab | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Quality Assurance"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"lancedb>=0.5.0; extra == \"rag\"",
"sentence-transformers>=2.2.0; extra == \"rag\"",
"torch>=2.0.0; extra == \"rag\"",
"numpy>=1.24.0; extra == \"rag\""
] | [] | [] | [] | [
"Repository, https://github.com/felipefernandes/iara",
"Issues, https://github.com/felipefernandes/iara/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:07:26.247547 | iara_reviewer-1.6.0.tar.gz | 42,842 | 86/9d/2b2c2a90677873659fdce622d6624742f5ed1378f567011eb28ad97433aa/iara_reviewer-1.6.0.tar.gz | source | sdist | null | false | 09ec811e24a4fcfad711c93963652603 | ac57941022c6b34b510228a4e1176c6b95e18af129ebd93a6f6fb7e5670ff2f5 | 869d2b2c2a90677873659fdce622d6624742f5ed1378f567011eb28ad97433aa | MIT | [
"LICENSE"
] | 224 |
2.2 | cjm-transcript-segmentation | 0.0.2 | FastHTML text segmentation component for transcript decomposition with NLTK sentence splitting, interactive split/merge UI with token selector, and card stack navigation. | # cjm-transcript-segmentation
<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
## Install
``` bash
pip install cjm_transcript_segmentation
```
## Project Structure
nbs/
├── components/ (6)
│ ├── callbacks.ipynb # JavaScript callback generators for Phase 2 segmentation keyboard interaction
│ ├── card_stack_config.ipynb # Card stack configuration constants for the Phase 2 segmentation UI
│ ├── helpers.ipynb # Shared helper functions for the segmentation module
│ ├── keyboard_config.ipynb # Segmentation-specific keyboard actions, modes, and zone configuration
│ ├── segment_card.ipynb # Segment card component with view and split modes
│ └── step_renderer.ipynb # Composable renderers for the Phase 2 segmentation column and shared chrome
├── routes/ (4)
│ ├── card_stack.ipynb # Card stack UI operations — navigation, viewport, mode switching, and response builders
│ ├── core.ipynb # Segmentation step state management helpers
│ ├── handlers.ipynb # Segmentation workflow handlers — init, split, merge, undo, reset, AI split
│ └── init.ipynb # Router assembly for Phase 2 segmentation routes
├── services/ (1)
│ └── segmentation.ipynb # Segmentation service for text decomposition via NLTK plugin
├── html_ids.ipynb # HTML ID constants for Phase 2 Left Column: Text Segmentation
├── models.ipynb # Data models and URL bundles for Phase 2 Left Column: Text Segmentation
└── utils.ipynb # Text processing utilities for segmentation: word counting, position mapping, and statistics
Total: 14 notebooks across 3 directories
## Module Dependencies
``` mermaid
graph LR
components_callbacks[components.callbacks<br/>callbacks]
components_card_stack_config[components.card_stack_config<br/>card_stack_config]
components_helpers[components.helpers<br/>helpers]
components_keyboard_config[components.keyboard_config<br/>keyboard_config]
components_segment_card[components.segment_card<br/>segment_card]
components_step_renderer[components.step_renderer<br/>step_renderer]
html_ids[html_ids<br/>html_ids]
models[models<br/>models]
routes_card_stack[routes.card_stack<br/>card_stack]
routes_core[routes.core<br/>core]
routes_handlers[routes.handlers<br/>handlers]
routes_init[routes.init<br/>init]
services_segmentation[services.segmentation<br/>segmentation]
utils[utils<br/>utils]
components_helpers --> models
components_keyboard_config --> components_card_stack_config
components_segment_card --> components_card_stack_config
components_segment_card --> html_ids
components_segment_card --> models
components_step_renderer --> components_card_stack_config
components_step_renderer --> html_ids
components_step_renderer --> utils
components_step_renderer --> components_segment_card
components_step_renderer --> models
components_step_renderer --> components_callbacks
routes_card_stack --> routes_core
routes_card_stack --> utils
routes_card_stack --> components_segment_card
routes_card_stack --> components_card_stack_config
routes_card_stack --> models
routes_card_stack --> components_step_renderer
routes_core --> models
routes_handlers --> components_card_stack_config
routes_handlers --> services_segmentation
routes_handlers --> html_ids
routes_handlers --> routes_core
routes_handlers --> components_step_renderer
routes_handlers --> utils
routes_handlers --> routes_card_stack
routes_handlers --> models
routes_init --> routes_handlers
routes_init --> services_segmentation
routes_init --> routes_card_stack
routes_init --> routes_core
routes_init --> models
services_segmentation --> models
utils --> models
```
*33 cross-module dependencies detected*
## CLI Reference
No CLI commands found in this project.
## Module Overview
Detailed documentation for each module in the project:
### callbacks (`callbacks.ipynb`)
> JavaScript callback generators for Phase 2 segmentation keyboard
> interaction
#### Import
``` python
from cjm_transcript_segmentation.components.callbacks import (
generate_seg_callbacks_script
)
```
#### Functions
``` python
def _generate_focus_change_script(
focus_input_id: str, # ID of hidden input for focused segment index
) -> str: # JavaScript code for focus change callback
"Generate JavaScript for card focus change handling."
```
``` python
def generate_seg_callbacks_script(
ids:CardStackHtmlIds, # Card stack HTML IDs
button_ids:CardStackButtonIds, # Card stack button IDs
config:CardStackConfig, # Card stack configuration
urls:CardStackUrls, # Card stack URL bundle
container_id:str, # ID of the segmentation container (parent of card stack)
focus_input_id:str, # ID of hidden input for focused segment index
) -> any: # Script element with all JavaScript callbacks
"""
Generate JavaScript for segmentation keyboard interaction.
Delegates card-stack-generic JS to the library and injects the
focus change callback via extra_scripts.
"""
```
### card_stack (`card_stack.ipynb`)
> Card stack UI operations — navigation, viewport, mode switching, and
> response builders
#### Import
``` python
from cjm_transcript_segmentation.routes.card_stack import (
init_card_stack_router
)
```
#### Functions
``` python
def _make_renderer(
urls: SegmentationUrls, # URL bundle
is_split_mode: bool = False, # Whether split mode is active
caret_position: int = 0, # Caret position for split mode
source_boundaries: Set[int] = None, # Indices where source_id changes
) -> Any: # Card renderer callback
"Create a segment card renderer with captured URLs and mode state."
```
``` python
def _build_slots_oob(
segment_dicts: List[Dict[str, Any]], # Serialized segments
state: CardStackState, # Card stack viewport state
urls: SegmentationUrls, # URL bundle
caret_position: int = 0, # Caret position for split mode
) -> List[Any]: # OOB slot elements
"Build OOB slot updates for the viewport sections."
```
``` python
def _build_nav_response(
segment_dicts: List[Dict[str, Any]], # Serialized segments
state: CardStackState, # Card stack viewport state
urls: SegmentationUrls, # URL bundle
caret_position: int = 0, # Caret position for split mode
) -> Tuple: # OOB elements (slots + progress + focus)
"Build OOB response for navigation and mode changes."
```
``` python
def _handle_seg_navigate(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
sess, # FastHTML session object
direction: str, # Navigation direction: "up", "down", "first", "last", "page_up", "page_down"
urls: SegmentationUrls, # URL bundle for segmentation routes
): # OOB slot updates with progress, focus, and source position
"Navigate to a different segment in the viewport using OOB slot swaps."
```
``` python
def _handle_seg_enter_split_mode(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
segment_index: int, # Index of segment to enter split mode for
urls: SegmentationUrls, # URL bundle for segmentation routes
): # OOB slot updates with split mode active for focused segment
"Enter split mode for a specific segment."
```
``` python
def _handle_seg_exit_split_mode(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
urls: SegmentationUrls, # URL bundle for segmentation routes
): # OOB slot updates with split mode deactivated
"Exit split mode."
```
``` python
async def _handle_seg_update_viewport(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
visible_count: int, # New number of visible cards
urls: SegmentationUrls, # URL bundle for segmentation routes
): # Full viewport component (outerHTML swap)
"""
Update the viewport with a new card count.
Does a full viewport swap because the number of slots changes.
Saves the new visible_count and is_auto_mode to state.
"""
```
``` python
def _handle_seg_save_width(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
sess, # FastHTML session object
card_width: int, # Card stack width in rem
) -> None: # No response body (swap=none on client)
"""
Save the card stack width to server state.
Called via debounced HTMX POST from the width slider.
Returns nothing since the client uses hx-swap='none'.
"""
```
``` python
def init_card_stack_router(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
prefix: str, # Route prefix (e.g., "/workflow/seg/card_stack")
urls: SegmentationUrls, # URL bundle (populated after routes defined)
) -> Tuple[APIRouter, Dict[str, Callable]]: # (router, route_dict)
"Initialize card stack routes for segmentation."
```
### card_stack_config (`card_stack_config.ipynb`)
> Card stack configuration constants for the Phase 2 segmentation UI
#### Import
``` python
from cjm_transcript_segmentation.components.card_stack_config import (
SEG_CS_CONFIG,
SEG_CS_IDS,
SEG_CS_BTN_IDS,
SEG_TS_CONFIG,
SEG_TS_IDS
)
```
#### Variables
``` python
SEG_CS_CONFIG
SEG_CS_IDS
SEG_CS_BTN_IDS
SEG_TS_CONFIG
SEG_TS_IDS
```
### core (`core.ipynb`)
> Segmentation step state management helpers
#### Import
``` python
from cjm_transcript_segmentation.routes.core import (
WorkflowStateStore,
DEBUG_SEG_STATE,
DEFAULT_MAX_HISTORY_DEPTH,
SegContext
)
```
#### Functions
``` python
def _to_segments(
segment_dicts: List[Dict[str, Any]] # Serialized segment dictionaries
) -> List[TextSegment]: # Deserialized TextSegment objects
"Convert segment dictionaries to TextSegment objects."
```
``` python
def _get_seg_state(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
session_id: str # Session identifier string
) -> SegmentationStepState: # Segmentation step state dictionary
"Get the segmentation step state from the workflow state store."
```
``` python
def _get_selection_state(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
session_id: str # Session identifier string
) -> Dict[str, Any]: # Selection step state dictionary
"Get the selection step state (Phase 1) from the workflow state store."
```
``` python
def _build_card_stack_state(
ctx: SegContext, # Loaded segmentation context
active_mode: str = None, # Active interaction mode (e.g. "split")
) -> CardStackState: # Card stack state for library functions
"Build a CardStackState from segmentation context for library calls."
```
``` python
def _load_seg_context(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
session_id: str # Session identifier string
) -> SegContext: # Common segmentation state values
"Load commonly-needed segmentation state values in a single call."
```
``` python
def _update_seg_state(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
session_id: str, # Session identifier string
segments: List[Dict[str, Any]] = None, # Updated segments (None = don't change)
initial_segments: List[Dict[str, Any]] = None, # Initial segments for reset (None = don't change)
focused_index: int = None, # Updated focused index (None = don't change)
is_initialized: bool = None, # Initialization flag (None = don't change)
history: List[Dict[str, Any]] = None, # Updated history (None = don't change)
visible_count: int = None, # Visible card count (None = don't change)
is_auto_mode: bool = None, # Auto-adjust mode flag (None = don't change)
card_width: int = None, # Card stack width in rem (None = don't change)
) -> None
"Update the segmentation step state in the workflow state store."
```
``` python
def _push_history(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
session_id: str, # Session identifier string
current_segments: List[Dict[str, Any]], # Current segments to snapshot
focused_index: int, # Current focused index to snapshot
max_history_depth: int = DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
) -> int: # New history depth after push
"Push current state to history stack before making changes."
```
#### Classes
``` python
class SegContext(NamedTuple):
"Common segmentation state values loaded by handlers."
```
#### Variables
``` python
DEBUG_SEG_STATE = False
DEFAULT_MAX_HISTORY_DEPTH = 50
```
### handlers (`handlers.ipynb`)
> Segmentation workflow handlers — init, split, merge, undo, reset, AI
> split
#### Import
``` python
from cjm_transcript_segmentation.routes.handlers import (
DEBUG_SEG_HANDLERS,
SegInitResult,
init_workflow_router
)
```
#### Functions
``` python
def _build_mutation_response(
segment_dicts:List[Dict[str, Any]], # Serialized segments
focused_index:int, # Currently focused segment index
visible_count:int, # Number of visible cards
history_depth:int, # Current undo history depth
urls:SegmentationUrls, # URL bundle
is_split_mode:bool=False, # Whether split mode is active
is_auto_mode:bool=False, # Whether card count is in auto-adjust mode
) -> Tuple: # OOB elements (slots + progress + focus + stats + toolbar + source position)
"""
Build the standard OOB response for mutation handlers.
Returns domain-specific OOB elements. The combined layer wrapper
adds cross-domain elements (mini-stats badge, alignment status).
"""
```
``` python
async def _handle_seg_init(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
source_service: SourceService, # Service for fetching source blocks
segmentation_service: SegmentationService, # Service for NLTK sentence splitting
request, # FastHTML request object
sess, # FastHTML session object
urls: SegmentationUrls, # URL bundle for segmentation routes
visible_count: int = DEFAULT_VISIBLE_COUNT, # Number of visible cards
card_width: int = DEFAULT_CARD_WIDTH, # Card stack width in rem
) -> SegInitResult: # Pure domain result for wrapper to use
"""
Initialize segments from Phase 1 selected sources.
Returns pure domain data. The combined layer wrapper adds cross-domain
coordination (KB system, shared chrome, alignment status).
"""
```
``` python
async def _handle_seg_split(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
segment_index: int, # Index of segment to split
urls: SegmentationUrls, # URL bundle for segmentation routes
max_history_depth: int = DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
): # OOB slot updates with stats, progress, focus, and toolbar
"Split a segment at the specified word position."
```
``` python
def _build_merge_reject_flash(
prev_index:int, # Index of the segment above the boundary
curr_index:int, # Index of the segment below the boundary
) -> Div: # OOB div containing JS that flashes both boundary cards
"Build an OOB element that flashes both cards at a source boundary."
```
``` python
def _handle_seg_merge(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
segment_index: int, # Index of segment to merge (merges with previous)
urls: SegmentationUrls, # URL bundle for segmentation routes
max_history_depth: int = DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
): # OOB slot updates with stats, progress, focus, and toolbar
"Merge a segment with the previous segment."
```
``` python
def _handle_seg_undo(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
urls: SegmentationUrls, # URL bundle for segmentation routes
): # OOB slot updates with stats, progress, focus, and toolbar
"Undo the last operation by restoring previous state from history."
```
``` python
def _handle_seg_reset(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
request, # FastHTML request object
sess, # FastHTML session object
urls: SegmentationUrls, # URL bundle for segmentation routes
max_history_depth: int = DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
): # OOB slot updates with stats, progress, focus, and toolbar
"Reset segments to the initial NLTK split result."
```
``` python
async def _handle_seg_ai_split(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
segmentation_service: SegmentationService, # Service for NLTK sentence splitting
request, # FastHTML request object
sess, # FastHTML session object
urls: SegmentationUrls, # URL bundle for segmentation routes
max_history_depth: int = DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
): # OOB slot updates with stats, progress, focus, and toolbar
"Re-run AI (NLTK) sentence splitting on all current text."
```
``` python
def init_workflow_router(
state_store: WorkflowStateStore, # The workflow state store
workflow_id: str, # The workflow identifier
source_service: SourceService, # Service for fetching source blocks
segmentation_service: SegmentationService, # Service for NLTK sentence splitting
prefix: str, # Route prefix (e.g., "/workflow/seg/workflow")
urls: SegmentationUrls, # URL bundle (populated after routes defined)
max_history_depth: int = DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
handler_init: Callable = None, # Optional wrapped init handler
handler_split: Callable = None, # Optional wrapped split handler
handler_merge: Callable = None, # Optional wrapped merge handler
handler_undo: Callable = None, # Optional wrapped undo handler
handler_reset: Callable = None, # Optional wrapped reset handler
handler_ai_split: Callable = None, # Optional wrapped ai_split handler
) -> Tuple[APIRouter, Dict[str, Callable]]: # (router, route_dict)
"""
Initialize workflow routes for segmentation.
Accepts optional handler overrides for wrapping with cross-domain
coordination (e.g., KB system, shared chrome, alignment status).
"""
```
#### Classes
``` python
class SegInitResult(NamedTuple):
"""
Result from pure segmentation init handler.
Contains domain-specific data for the combined layer wrapper to use
when building cross-domain OOB elements (KB system, shared chrome).
"""
```
#### Variables
``` python
DEBUG_SEG_HANDLERS = True
```
### helpers (`helpers.ipynb`)
> Shared helper functions for the segmentation module
#### Import
``` python
from cjm_transcript_segmentation.components.helpers import *
```
#### Functions
``` python
def _get_segmentation_state(
ctx: InteractionContext # Interaction context with state
) -> SegmentationStepState: # Typed segmentation step state
"Get the full segmentation step state from context."
```
``` python
def _get_segments(
ctx: InteractionContext # Interaction context with state
) -> List[TextSegment]: # List of TextSegment objects
"Get the list of segments from step state as TextSegment objects."
```
``` python
def _is_initialized(
ctx: InteractionContext # Interaction context with state
) -> bool: # True if segments have been initialized
"Check if segments have been initialized."
```
``` python
def _get_visible_count(
ctx: InteractionContext, # Interaction context with state
default: int = 3, # Default visible card count
) -> int: # Number of visible cards in viewport
"Get the stored visible card count."
```
``` python
def _get_card_width(
ctx: InteractionContext, # Interaction context with state
default: int = 80, # Default card width in rem
) -> int: # Card stack width in rem
"Get the stored card stack width."
```
``` python
def _get_is_auto_mode(
ctx: InteractionContext, # Interaction context with state
) -> bool: # Whether card count is in auto-adjust mode
"Get whether the card count is in auto-adjust mode."
```
``` python
def _get_history(
ctx: InteractionContext # Interaction context with state
) -> List[List[Dict[str, Any]]]: # Stack of segment snapshots
"Get the undo history stack."
```
``` python
def _get_focused_index(
ctx: InteractionContext # Interaction context with state
) -> int: # Currently focused segment index
"Get the currently focused segment index."
```
### html_ids (`html_ids.ipynb`)
> HTML ID constants for Phase 2 Left Column: Text Segmentation
#### Import
``` python
from cjm_transcript_segmentation.html_ids import (
SegmentationHtmlIds
)
```
#### Classes
``` python
class SegmentationHtmlIds:
"HTML ID constants for Phase 2 Left Column: Text Segmentation."
def as_selector(
id_str:str # The HTML ID to convert
) -> str: # CSS selector with # prefix
"Convert an ID to a CSS selector format."
def segment_card(
index:int # Segment index in the decomposition
) -> str: # HTML ID for the segment card
"Generate HTML ID for a segment card."
```
### init (`init.ipynb`)
> Router assembly for Phase 2 segmentation routes
#### Import
``` python
from cjm_transcript_segmentation.routes.init import (
WrappedHandlers,
init_segmentation_routers
)
```
#### Functions
``` python
def init_segmentation_routers(
state_store:WorkflowStateStore, # The workflow state store
workflow_id:str, # The workflow identifier
source_service:SourceService, # Service for fetching source blocks
segmentation_service:SegmentationService, # Service for NLTK sentence splitting
prefix:str, # Base prefix for segmentation routes (e.g., "/workflow/seg")
max_history_depth:int=DEFAULT_MAX_HISTORY_DEPTH, # Maximum history stack depth
wrapped_handlers:WrappedHandlers=None, # Dict with 'init', 'split', 'merge', 'undo', 'reset', 'ai_split' keys
) -> Tuple[List[APIRouter], SegmentationUrls, Dict[str, Callable]]: # (routers, urls, merged_routes)
"""
Initialize and return all segmentation routers with URL bundle.
The wrapped_handlers dict should contain handlers that already have
cross-domain concerns (KB system, alignment status) handled by the
combined layer's wrapper factories.
"""
```
### keyboard_config (`keyboard_config.ipynb`)
> Segmentation-specific keyboard actions, modes, and zone configuration
#### Import
``` python
from cjm_transcript_segmentation.components.keyboard_config import (
SD_SEG_ENTER_SPLIT_BTN,
SD_SEG_EXIT_SPLIT_BTN,
SD_SEG_SPLIT_BTN,
SD_SEG_MERGE_BTN,
SD_SEG_UNDO_BTN,
create_seg_kb_parts
)
```
#### Functions
``` python
def create_seg_kb_parts(
ids:CardStackHtmlIds, # Card stack HTML IDs
button_ids:CardStackButtonIds, # Card stack button IDs for navigation
config:CardStackConfig, # Card stack configuration
) -> Tuple[FocusZone, tuple, tuple]: # (zone, actions, modes)
"""
Create segmentation-specific keyboard building blocks.
Returns a zone, actions tuple, and modes tuple for assembly into a shared
ZoneManager by the combined-level keyboard config.
"""
```
#### Variables
``` python
SD_SEG_ENTER_SPLIT_BTN = 'sd-seg-enter-split-btn'
SD_SEG_EXIT_SPLIT_BTN = 'sd-seg-exit-split-btn'
SD_SEG_SPLIT_BTN = 'sd-seg-split-btn'
SD_SEG_MERGE_BTN = 'sd-seg-merge-btn'
SD_SEG_UNDO_BTN = 'sd-seg-undo-btn'
```
### models (`models.ipynb`)
> Data models and URL bundles for Phase 2 Left Column: Text Segmentation
#### Import
``` python
from cjm_transcript_segmentation.models import (
TextSegment,
SegmentationStepState,
SegmentationUrls
)
```
#### Classes
``` python
@dataclass
class TextSegment:
"A text segment during workflow processing before graph commit."
index: int # Sequence position (0-indexed)
text: str # Segment text content
source_id: Optional[str] # ID of source block
source_provider_id: Optional[str] # Source provider identifier
start_char: Optional[int] # Start character index in source
end_char: Optional[int] # End character index in source
def to_dict(self) -> Dict[str, Any]: # Dictionary representation
"""Convert to dictionary for JSON serialization."""
return asdict(self)
@classmethod
def from_dict(
cls,
data: Dict[str, Any] # Dictionary representation
) -> "TextSegment": # Reconstructed TextSegment
"Convert to dictionary for JSON serialization."
def from_dict(
cls,
data: Dict[str, Any] # Dictionary representation
) -> "TextSegment": # Reconstructed TextSegment
"Create from dictionary, filtering out legacy/unknown fields."
```
``` python
class SegmentationStepState(TypedDict):
"State for Phase 2 (left column): Text Segmentation."
```
``` python
@dataclass
class SegmentationUrls:
"URL bundle for Phase 2 segmentation route handlers and renderers."
card_stack: CardStackUrls = field(...)
split: str = '' # Execute split at word position
merge: str = '' # Merge segment with previous
enter_split: str = '' # Enter split mode for focused segment
exit_split: str = '' # Exit split mode
reset: str = '' # Reset to initial segments
ai_split: str = '' # AI (NLTK) re-split
undo: str = '' # Undo last operation
init: str = '' # Initialize segments from Phase 1
```
### segment_card (`segment_card.ipynb`)
> Segment card component with view and split modes
#### Import
``` python
from cjm_transcript_segmentation.components.segment_card import (
render_segment_card,
create_segment_card_renderer
)
```
#### Functions
``` python
def _render_card_metadata(
segment:TextSegment, # Segment to render metadata for
) -> Any: # Metadata component
"Render the left metadata column of a segment card."
```
``` python
def _render_view_mode_content(
segment: TextSegment, # Segment to render
card_role: CardRole, # Role of this card in viewport
enter_split_url: str, # URL to enter split mode
) -> Any: # View mode content component
"Render the text content in view mode."
```
``` python
def _render_split_mode_content(
segment:TextSegment, # Segment to render
caret_position:int, # Current caret position (token index)
split_url:str, # URL to execute split
exit_split_url:str, # URL to exit split mode
) -> Any: # Split mode content component
"Render the interactive token display in split mode."
```
``` python
def _render_card_actions(
"Render hover-visible action buttons."
```
``` python
def render_segment_card(
"Render a segment card with view or split mode content."
```
``` python
def create_segment_card_renderer(
split_url: str = "", # URL to execute split
merge_url: str = "", # URL to merge with previous
enter_split_url: str = "", # URL to enter split mode
exit_split_url: str = "", # URL to exit split mode
is_split_mode: bool = False, # Whether split mode is active
caret_position: int = 0, # Caret position for split mode (word index)
source_boundaries: Set[int] = None, # Indices where source_id changes
) -> Callable: # Card renderer callback: (item, CardRenderContext) -> FT
"Create a card renderer callback for segment cards."
```
### segmentation (`segmentation.ipynb`)
> Segmentation service for text decomposition via NLTK plugin
#### Import
``` python
from cjm_transcript_segmentation.services.segmentation import (
SegmentationService,
split_segment_at_position,
merge_text_segments,
reindex_segments,
reconstruct_source_blocks
)
```
#### Functions
``` python
def split_segment_at_position(
segment: TextSegment, # Segment to split
char_position: int # Character position to split at (relative to segment text)
) -> tuple[TextSegment, TextSegment]: # Two new segments
"Split a segment into two at the given character position."
```
``` python
def merge_text_segments(
first: TextSegment, # First segment (earlier in sequence)
second: TextSegment, # Second segment (later in sequence)
separator: str = " " # Text separator between segments
) -> TextSegment: # Merged segment
"Merge two adjacent segments into one."
```
``` python
def reindex_segments(
segments: List[TextSegment] # List of segments to reindex
) -> List[TextSegment]: # Segments with corrected indices
"Reindex segments to have sequential indices starting from 0."
```
``` python
def reconstruct_source_blocks(
segment_dicts: List[Dict[str, Any]], # Serialized working segments
) -> List[SourceBlock]: # Reconstructed source blocks with combined text
"Reconstruct source blocks by grouping segments by source_id and combining text."
```
#### Classes
``` python
class SegmentationService:
def __init__(
self,
plugin_manager: PluginManager, # Plugin manager for accessing text plugin
plugin_name: str = "cjm-text-plugin-nltk" # Name of the text processing plugin
)
"Service for text segmentation via NLTK plugin."
def __init__(
self,
plugin_manager: PluginManager, # Plugin manager for accessing text plugin
plugin_name: str = "cjm-text-plugin-nltk" # Name of the text processing plugin
)
"Initialize the segmentation service."
def is_available(self) -> bool: # True if plugin is loaded and ready
"""Check if the text processing plugin is available."""
return self._manager.get_plugin(self._plugin_name) is not None
def ensure_loaded(
self,
config: Optional[Dict[str, Any]] = None # Optional plugin configuration
) -> bool: # True if successfully loaded
"Check if the text processing plugin is available."
def ensure_loaded(
self,
config: Optional[Dict[str, Any]] = None # Optional plugin configuration
) -> bool: # True if successfully loaded
"Ensure the text processing plugin is loaded."
async def split_sentences_async(
self,
text: str, # Text to split into sentences
source_id: Optional[str] = None, # Source block ID for traceability
source_provider_id: Optional[str] = None # Source provider identifier for traceability
) -> List[TextSegment]: # List of TextSegment objects
"Split text into sentences asynchronously."
def split_sentences(
self,
text: str, # Text to split into sentences
source_id: Optional[str] = None, # Source block ID for traceability
source_provider_id: Optional[str] = None # Source provider identifier for traceability
) -> List[TextSegment]: # List of TextSegment objects
"Split text into sentences synchronously."
async def split_combined_sources_async(
self,
source_blocks: List[SourceBlock] # Ordered list of source blocks
) -> List[TextSegment]: # Combined list of TextSegments with proper traceability
"Split multiple source blocks into segments with proper source tracking."
```
### step_renderer (`step_renderer.ipynb`)
> Composable renderers for the Phase 2 segmentation column and shared
> chrome
#### Import
``` python
from cjm_transcript_segmentation.components.step_renderer import (
render_toolbar,
render_seg_stats,
render_seg_source_position,
render_seg_column_body,
render_seg_footer_content,
render_seg_mini_stats_text
)
```
#### Functions
``` python
def render_toolbar(
reset_url: str, # URL for reset action
ai_split_url: str, # URL for AI split action
undo_url: str, # URL for undo action
can_undo: bool, # Whether undo is available
visible_count: int = DEFAULT_VISIBLE_COUNT, # Current visible card count
is_auto_mode: bool = False, # Whether card count is in auto-adjust mode
oob: bool = False, # Whether to render as OOB swap
) -> Any: # Toolbar component
"Render the segmentation toolbar with action buttons and card count selector."
```
``` python
def render_seg_stats(
segments: List[TextSegment], # Current segments
oob: bool = False, # Whether to render as OOB swap
) -> Any: # Statistics component
"Render segmentation statistics."
```
``` python
def render_seg_source_position(
segments: List[TextSegment], # Current segments
focused_index: int = 0, # Currently focused segment index
oob: bool = False, # Whether to render as OOB swap
) -> Any: # Source position indicator (empty if single source)
"Render source position indicator for the focused segment."
```
``` python
def render_seg_column_body(
segments:List[TextSegment], # Segments to display
focused_index:int, # Currently focused segment index
visible_count:int, # Number of visible cards in viewport
card_width:int, # Card stack width in rem
urls:SegmentationUrls, # URL bundle for all segmentation routes
kb_system:Optional[Any]=None, # Rendered keyboard system (None when KB managed externally)
) -> Any: # Div with id=COLUMN_CONTENT containing viewport + infrastructure
"Render the segmentation column content area with card stack viewport."
```
``` python
def render_seg_footer_content(
segments:List[TextSegment], # Current segments
focused_index:int, # Currently focused segment index
) -> Any: # Footer content with progress indicator, source position, and stats
"Render footer content with progress indicator, source position, and segment statistics."
```
``` python
def render_seg_mini_stats_text(
segments:List[TextSegment], # Current segments
) -> str: # Compact stats string for column header badge
"Generate compact stats string for the segmentation column header badge."
```
### utils (`utils.ipynb`)
> Text processing utilities for segmentation: word counting, position
> mapping, and statistics
#### Import
``` python
from cjm_transcript_segmentation.utils import (
count_words,
word_index_to_char_position,
calculate_segment_stats,
get_source_boundaries,
get_source_count,
get_source_position
)
```
#### Functions
``` python
def count_words(
text: str # Text to count words in
) -> int: # Word count
"Count the number of whitespace-delimited words in text."
```
``` python
def word_index_to_char_position(
text: str, # Full text
word_index: int # Word index (0-based, split happens before this word)
) -> int: # Character position for split
"Convert a word index to the character position where a split should occur."
```
``` python
def calculate_segment_stats(
segments: List["TextSegment"] # List of segments to analyze
) -> Dict[str, Any]: # Statistics dictionary with total_words, total_segments
"Calculate aggregate statistics for a list of segments."
```
``` python
def get_source_boundaries(
segments: List["TextSegment"], # Ordered list of segments
) -> Set[int]: # Indices where source_id changes from the previous segment
"""
Find indices where source_id changes between adjacent segments.
A boundary at index N means segment[N].source_id differs from
segment[N-1].source_id. Both must be non-None for a boundary to exist.
"""
```
``` python
def get_source_count(
segments: List["TextSegment"], # Ordered list of segments
) -> int: # Number of unique non-None source_ids
"Count the number of unique audio sources in the segment list."
```
``` python
def get_source_position(
segments: List["TextSegment"], # Ordered list of segments
focused_index: int, # Index of the focused segment
) -> Optional[int]: # 1-based position in ordered unique sources, or None
"""
Get the source position (1-based) of the focused segment.
Returns which source group the focused segment belongs to,
based on order of first appearance.
"""
```
| text/markdown | Christian J. Mills | 9126128+cj-mills@users.noreply.github.com | null | null | Apache-2.0 | nbdev jupyter notebook python | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Natural Language :: English",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | https://github.com/cj-mills/cjm-transcript-segmentation | null | >=3.12 | [] | [] | [] | [
"cjm-plugin-system",
"cjm-transcription-plugin-system",
"cjm-fasthtml-app-core",
"cjm-fasthtml-daisyui",
"cjm_fasthtml_lucide_icons",
"cjm_fasthtml_file_browser",
"cjm_fasthtml_keyboard_navigation",
"cjm_fasthtml_card_stack",
"cjm_fasthtml_token_selector",
"duckdb",
"pandas",
"cjm_workflow_state",
"cjm_source_provider",
"cjm_fasthtml_interactions",
"cjm_transcript_source_select"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-21T04:06:59.858213 | cjm_transcript_segmentation-0.0.2.tar.gz | 53,269 | 8e/6b/c29e36834b70584eb61ae560074056bf265fe79775bbf069abf01515da2f/cjm_transcript_segmentation-0.0.2.tar.gz | source | sdist | null | false | 5c9e12402c3f136d70b781c095d5c850 | c2b8707e2e38aa190f7efb7e2baec925d5a7455951c6a86ad3aa9893837d0acb | 8e6bc29e36834b70584eb61ae560074056bf265fe79775bbf069abf01515da2f | null | [] | 218 |
2.4 | chromedriver-binary | 147.0.7698.0.0 | Installer for chromedriver. | # chromedriver-binary
Downloads and installs the [chromedriver](https://sites.google.com/a/chromium.org/chromedriver/) binary version 147.0.7698.0 for automated testing of webapps. The installer supports Linux, MacOS and Windows operating systems.
Alternatively the package [chromedriver-binary-auto](https://pypi.org/project/chromedriver-binary-auto/) can be used to automatically detect the latest chromedriver version required for the installed Chrome/Chromium browser.
## Installation
### Latest and fixed versions
#### From PyPI
```
pip install chromedriver-binary
```
#### From GitHub
```
pip install git+https://github.com/danielkaiser/python-chromedriver-binary.git
```
### Automatically detected versions
Please make sure to install Chrome or Chromium first and add the browser to the binary search path.
#### From PyPI
```
pip install chromedriver-binary-auto
```
To redetect the required version and install the newest suitable chromedriver after the first installation simply reinstall the package using
```
pip install --upgrade --force-reinstall chromedriver-binary-auto
```
#### From GitHub
```
pip install git+https://github.com/danielkaiser/python-chromedriver-binary.git@chromedriver-binary-auto
```
If the installed chromedriver version does not match your browser's version please try to [empty pip's cache](https://pip.pypa.io/en/stable/cli/pip_cache/) or disable the cache during (re-)installation.
## Usage
To use chromedriver just `import chromedriver_binary`. This will add the executable to your PATH so it will be found. You can also get the absolute filename of the binary with `chromedriver_binary.chromedriver_filename`.
### Example
```
from selenium import webdriver
import chromedriver_binary # Adds chromedriver binary to path
driver = webdriver.Chrome()
driver.get("http://www.python.org")
assert "Python" in driver.title
```
### Exporting chromedriver binary path
This package installs a small shell script `chromedriver-path` to easily set and export the PATH variable:
```
$ export PATH=$PATH:`chromedriver-path`
```
| text/markdown | Daniel Kaiser | daniel.kaiser94@gmail.com | null | null | MIT | chromedriver chrome browser selenium splinter | [
"Development Status :: 5 - Production/Stable",
"Topic :: Software Development :: Testing",
"Topic :: System :: Installation/Setup",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved :: MIT License"
] | [] | https://github.com/danielkaiser/python-chromedriver-binary | null | null | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.3 | 2026-02-21T04:04:56.276009 | chromedriver_binary-147.0.7698.0.0.tar.gz | 5,657 | 67/13/8bae262add12a276cc243c22d6d48d70a438344a5264f60697867ae198f6/chromedriver_binary-147.0.7698.0.0.tar.gz | source | sdist | null | false | b11e695654895fc9d0fef4f902fbd909 | 9b3730654bc6de523c7adda48362cb1499bd0ecd4aa6a129112b06d71d06262e | 67138bae262add12a276cc243c22d6d48d70a438344a5264f60697867ae198f6 | null | [
"LICENSE"
] | 369 |
2.4 | webagents-md | 0.1.0 | Parse, discover, and use webagents.md tool manifests for AI agents | # webagents.md
https://github.com/user-attachments/assets/27542a07-350f-4c26-8fb4-36d8c8fc7e1a
This is a proposed spec and Python SDK that lets websites expose tools for AI agents to call directly in the browser. A site publishes a Markdown file describing its tools, and any agent can discover and use them.
If adopted broadly, `webagents.md` is how AI agents navigate the web autonomously--not by clicking through interfaces built for humans, but by calling functions that websites explicitly provide to them.
**How it works:** A website publishes a `webagents.md` file listing its tools and adds a `<meta>` tag for discovery. The SDK detects the tag, parses the manifest, and converts the tools into TypeScript declarations. The LLM gets those declarations as context plus a single `execute_js` tool.
The agent writes code like `await global.searchProducts("red shoes")`, and the runtime executes it in the browser via Playwright. Multiple calls can be chained in one shot.
**What the SDK provides:**
- For builders of AI agents, it detects a site's manifest, parses the tools, generates TypeScript declarations for the LLM, and executes LLM-written code in the browser.
- For website developers, it lets them build and validate manifests programmatically.
## Why `webagents.md` exists
Most web agents today behave in one of two ways:
- They view websites and **simulate clicks and keystrokes**, pretending to be a human. This is not deterministic and can be time-consuming, token-intensive, and prone to failure.
- They rely on **backend-only integrations** (MCP servers, custom APIs, OpenAPI specs) that are fragmented and require configuration.
At the same time, we've learned a few key things about LLMs:
- LLMs are **[much better at writing code](https://blog.cloudflare.com/code-mode)** than at making tool calls. They've seen millions of TypeScript APIs in training, but only a smaller set of contrived tool-calling examples.
- When an LLM can write code, it can chain multiple calls in one shot. It can also branch on results, looping over items, transforming data, handling errors, etc.
`webagents.md` is a simple answer to this:
- It's **framework-agnostic**: one Markdown file works with any LLM that can write TypeScript.
- It's **code-first**: the SDK converts tool declarations into TypeScript interfaces that LLMs write code against.
- It's **website-owned**: the site itself declares what tools exist and how they should be used.
It's like a **robots.txt for AI tools**: instead of telling crawlers which URLs to avoid, it tells agents which functions they can call.
## High-level overview
There are two audiences:
- **Agent developers**
- Detect `webagents.md` on any site.
- Parse the tools into TypeScript declarations.
- Pass them to an LLM, which writes code that calls the tools directly in the browser.
- **Website developers**
- Define tools in a Markdown file (`webagents.md`).
- Optionally generate and validate that file using this SDK.
- Implement the corresponding JavaScript functions on their site.
At a high level:
1. A site adds **`webagents.md`** and a `<meta>` tag.
2. An agent runtime detects it.
3. The SDK converts the manifest into TypeScript declarations.
4. The LLM writes code like `const results = await global.searchProducts("red shoes");`.
5. The runtime executes that code in the browser, where the `global.*` functions already exist.
## Example
A website publishes a `webagents.md` file listing tools AI agents can use, and adds a `<meta>` tag to `<head>` for discovery:
```html
<meta name="webagents-md" content="/webagents.md">
```
Here's what that file looks like:
``````markdown
# Example Store
Simple online store for shoes and accessories.
## Important
- User must be logged in for cart operations.
- searchProducts is rate-limited to 10 calls/minute.
## searchProducts
Search the product catalog by keyword.
### Params
- `query` (string, required): Search query text.
- `limit` (number, optional, default=20): Maximum results.
### Output
```typescript
{ products: Array<{ id: string; name: string; price: number }>; total: number }
```
### Sample Code
```js
const results = await global.searchProducts(query);
```
## addToCart
Add a product to the shopping cart.
### Params
- `productId` (string, required): Unique product ID.
- `quantity` (number, optional, default=1): Quantity to add.
### Output
```typescript
{ cartId: string; items: Array<{ productId: string; quantity: number }> }
```
### Sample Code
```js
await global.addToCart(productId, quantity);
```
``````
That's it.
The SDK converts this into TypeScript declarations the LLM writes code against:
```typescript
declare const global: {
/** Search the product catalog by keyword. */
searchProducts(query: string, limit?: number): Promise<{
products: Array<{ id: string; name: string; price: number }>;
total: number;
}>;
/** Add a product to the shopping cart. */
addToCart(productId: string, quantity?: number): Promise<{
cartId: string;
items: Array<{ productId: string; quantity: number }>;
}>;
};
```
The LLM then writes code like:
```typescript
const results = await global.searchProducts("red shoes");
const top = results.products[0];
await global.addToCart(top.id, 2);
console.log(`Added ${top.name} to cart`);
```
## Why Markdown?
Everything in `webagents.md` is context for the LLM:
- **Tool declarations** → converted to TypeScript declarations the LLM writes code against.
- **`### Output` blocks** → become return types in the TypeScript, so the LLM knows what it gets back.
- **`### Sample Code` blocks** → documentation showing calling conventions.
- **Everything else** (instructions, rate limits, workflows, resources) → passed as-is to the LLM alongside the TypeScript.
The manifest serves as documentation, prompt, and tool definition all at once.
## Installation
```bash
pip install webagents-md
```
## For agent developers
### Detect and get TypeScript declarations
```python
import asyncio
from webagent import AgentClient
async def main():
async with AgentClient() as agent:
# Detect webagents.md on a website (via <meta name="webagents-md">)
await agent.detect("https://shop.example.com")
# Get TypeScript declarations — pass this to your LLM
ts = agent.typescript()
# => 'declare const global: { searchProducts(...): Promise<...>; ... };'
# Or get full LLM context (TypeScript + raw markdown instructions)
context = agent.context_for_llm()
asyncio.run(main())
```
### Build an agent loop
`AgentClient` provides everything needed for a full agent loop — system prompt, tool schema, and browser execution:
```python
import asyncio
from webagent import AgentClient
async def main():
async with AgentClient() as agent:
await agent.detect("https://shop.example.com")
# List available tools
print(agent.list_tools()) # ['searchProducts', 'addToCart', ...]
# Get a complete system prompt (TypeScript API + instructions for the LLM)
prompt = agent.system_prompt(task="Find red shoes and add them to cart")
# Get the generic execute_js tool schema (OpenAI function-calling format)
tool = agent.execute_tool()
# Execute LLM-generated JavaScript in the browser (via a Playwright page)
result = await agent.execute(page, 'return await global.searchProducts("red shoes")')
asyncio.run(main())
```
You can also load a manifest directly from a known URL (skipping `<meta>` tag detection):
```python
await agent.load("https://shop.example.com/webagents.md")
```
## For website developers
You can build and validate a `webagents.md` manifest programmatically:
```python
from webagent import Param, build_manifest, build_tool, meta_tag, to_markdown, validate, write_file
# Define tools
search = build_tool(
name="searchProducts",
description="Search the product catalog.",
params=[
("query", "string", "Search query text."),
],
sample_code="const results = await global.searchProducts(query);",
)
# For optional params, use Param directly
snapshot = build_tool(
name="getPageSnapshot",
description="Return a structured snapshot of current page state.",
params=[],
sample_code="const snapshot = await global.getPageSnapshot(mode);",
)
snapshot.params = [
Param(name="mode", type="string", description='Snapshot mode.', required=False, default="full"),
]
# Build a manifest
manifest = build_manifest("My Store", tools=[search, snapshot])
# Validate it (checks names, descriptions, params, duplicates)
warnings = validate(manifest)
if warnings:
print("Warnings:", warnings)
# Serialize to Markdown
md = to_markdown(manifest)
print(md)
# Or write directly to a file
write_file(manifest, "./webagents.md")
# Generate the HTML meta tag for discovery
print(meta_tag()) # <meta name="webagents-md" content="/webagents.md">
```
> **Note:** `build_tool` creates all params as required by default. For optional params with defaults, use the `Param` class directly as shown above.
And then:
1. Save `md` as `/webagents.md` on your site.
2. Add the `<meta name="webagents-md" content="/webagents.md">` tag to `<head>`.
3. Implement the corresponding JavaScript functions:
```js
// On the website:
global.searchProducts = async (query, limit = 20) => {
const resp = await fetch(`/api/search?q=${encodeURIComponent(query)}&limit=${limit}`);
if (!resp.ok) throw new Error("Search failed");
return await resp.json();
};
```
## Manifest formats
The SDK can parse two formats. Both are valid Markdown, and both produce the same internal `Tool` objects.
### Heading format (recommended)
This is the format shown throughout this README. Tools are `##` headings, with `### Params`, `### Output`, and `### Sample Code` subsections. It's designed to be written by hand and read like documentation. The `### Output` section is optional. When present, it becomes the return type in the TypeScript declaration, and when absent the return type defaults to `Promise<any>`.
Any `##` section that isn't a tool (like `## Important` with instructions or rate limits) is preserved in `manifest.content` and included when you call `context_for_llm()`, so the LLM sees it as context alongside the TypeScript declarations.
### Compact format
An alternative format that's closer to a config file. Instead of headings, each tool starts with `tool:` followed by its signature, with indented `description`, `params`, `output`, and `sample_code` fields:
``````
tool: searchProducts(query, limit=20)
description: |
Search products by keyword.
params:
query: string
limit: number?
output:
```typescript
{ products: Array<{ id: string; name: string; price: number }>; total: number }
```
sample_code:
```js
const results = await global.searchProducts(query, limit);
```
tool: addToCart(productId, quantity=1)
description: |
Add a product to the cart.
params:
productId: string
quantity: number?
sample_code:
```js
await global.addToCart(productId, quantity);
```
``````
Default values and optional params are expressed in the signature (`limit=20`) and type (`number?`) rather than in prose.
## Auth and security
`webagents.md` does **not** define authentication; it assumes:
- Tools run in the **context of the browser**,
- Which means they can use:
- the current user’s logged-in session (cookies/tokens),
- or any existing API keys/headers the site already uses.
A typical pattern:
```js
global.getUserProfile = async () => {
const resp = await fetch("/api/user/me"); // browser sends cookies/headers as usual
if (resp.status === 401) throw new Error("Not logged in");
return await resp.json();
};
```
From the agent’s perspective, calling `getUserProfile()` is just:
```js
const profile = await global.getUserProfile();
```
If the user isn’t authenticated, the tool fails like it would for any other unauthenticated request. No secrets or tokens need to be embedded in `webagents.md`.
For cases where the agent isn't riding on an existing user session, websites can expose authentication tools in the manifest itself. For example, a `login` or `getAgentToken` tool could issue a scoped token for the agent to use in subsequent calls.
## Public API
Everything is importable from `webagent`:
| Function / Class | Description |
|---|---|
| `AgentClient` | High-level async client: detect, load, get TypeScript, execute JS in browser |
| `parse(markdown)` | Parse a `webagents.md` string into a `Manifest` |
| `parse_file(path)` | Parse a `webagents.md` file from disk |
| `generate_typescript(manifest)` | Generate `declare const global: { ... }` TypeScript declarations |
| `discover(url)` | Discover and parse a manifest from a web page |
| `discover_manifest_url(url)` | Get the manifest URL from a page's `<meta>` tag |
| `fetch_manifest(url)` | Fetch and parse a manifest from a direct URL |
| `build_manifest(name, ...)` | Build a `Manifest` programmatically |
| `build_tool(name, ...)` | Build a `Tool` from simple arguments |
| `validate(manifest)` | Validate a manifest, returns list of warnings |
| `to_markdown(manifest)` | Serialize a `Manifest` back to markdown |
| `write_file(manifest, path)` | Write a manifest to disk as markdown |
| `meta_tag(path)` | Generate the HTML `<meta>` discovery tag |
| `Manifest`, `Tool`, `Param` | Pydantic models |
## Architecture
Internally, `webagent` is:
```text
src/webagent/
├── __init__.py
├── types.py # Pydantic models: Param, Tool, Manifest
├── parser.py # Parse webagents.md → Manifest
├── discovery.py # Discover webagents.md via <meta name="webagents-md">
├── client.py # AgentClient (agent developer API)
├── codegen.py # Generate TypeScript declarations from tools
├── serializer.py # Manifest → webagents.md Markdown
└── site.py # Website developer helpers (build, validate, meta_tag)
```
You can use just the building blocks you need:
- Only `parser.py` + `types.py` if you're writing your own runtime.
- Or `client.py` if you want an all-in-one agent-side helper.
## Demo
The [`demo/`](demo/) directory contains a working end-to-end example: a bookstore website ("Books to Browse") that declares tools via `webagents.md`, and a Python script that runs an AI agent against it.
```bash
cd demo
pip install -r requirements.txt
playwright install chromium
python run_agent.py
```
The script starts a local server, discovers the site's tools, and runs an AI agent that writes and executes JavaScript in the browser. See [`demo/README.md`](demo/README.md) for details.
## Development
```bash
pip install -e ".[dev]"
pytest
ruff check src/ tests/
```
## License
MIT | text/markdown | null | null | null | null | null | null | [
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Typing :: Typed"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"httpx>=0.25.0",
"pydantic>=2.0",
"pytest-asyncio>=0.23; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.4; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.3 | 2026-02-21T04:04:00.125204 | webagents_md-0.1.0.tar.gz | 833,460 | 7e/33/f6080d46f273a31cc01ee614baccb07fc69f6d148c6793c918715d92f8e1/webagents_md-0.1.0.tar.gz | source | sdist | null | false | 4d1e9676373703bce4d481ec81f3ae46 | 458fa8db0647554cceaee889eb1da2c0acc7be5627e7ac2ed0ef3ec73d4e3c8e | 7e33f6080d46f273a31cc01ee614baccb07fc69f6d148c6793c918715d92f8e1 | MIT | [
"LICENSE"
] | 233 |
2.4 | model-metrics | 0.0.5a6 | A Python library for model evaluation, performance tracking, and metric visualizations, supporting classification and regression models with robust analytics and reporting. | <img src="https://raw.githubusercontent.com/lshpaner/model_metrics/refs/heads/main/assets/mm_logo.svg" width="300" style="border: none; outline: none; box-shadow: none;" oncontextmenu="return false;">
<br>
[](https://pypi.org/project/model_metrics/)
[](https://pepy.tech/project/model_metrics)
[](https://github.com/lshpaner/model_metrics/blob/main/LICENSE.md)
Welcome to Model Metrics! Model Metrics is a versatile Python library designed to streamline the evaluation and interpretation of machine learning models. It provides a robust framework for generating predictions, computing model metrics, analyzing feature importance, and visualizing results. Whether you're working with SHAP values, model coefficients, confusion matrices, ROC curves, precision-recall plots, and other key performance indicators.
---
## Prerequisites
Before you install `model_metrics`, ensure your system meets the following requirements:
- `Python`: Version `3.7.4` or higher.
Additionally, `model_metrics` depends on the following packages, which will be automatically installed when you install `model_metrics`:
- `matplotlib`: version `3.5.3` or higher, but capped at `3.10.0`
- `numpy`: version `1.21.6` or higher, but capped at `2.1.0`
- `pandas`: version `1.3.5` or higher, but capped at `2.2.3`
- `plotly`: version `5.18.0` or higher, but capped at `5.24.1`
- `scikit-learn`: version `1.0.2` or higher, but capped at `1.5.2`
- `scipy`: version `1.8` or higher, but capped at `1.14.0`
- `shap`: version `0.41.0` or higher, but capped below `0.46.0`
- `statsmodels`: version `0.12.2` or higher, but capped below `0.14.4`
- `tqdm`: version `4.66.4` or higher, but capped below `4.67.1`
## 💾 Installation
To install `model_metrics`, simply run the following command in your terminal:
```bash
pip install model_metrics
```
## 📄 Official Documentation
https://lshpaner.github.io/model_metrics_docs
## 🌐 Author's Website
1. [Leon Shpaner](https://www.leonshpaner.com)
## 🙏 Acknowledgements
Gratitude goes to Dr. Ebrahim Tarshizi for his mentorship during the University of San Diego M.S. Applied Data Science Program, as well as the Shiley-Marcos School of Engineering for its support.
Special thanks to Dr. Alex Bui, and to Panayiotis Petousis, PhD, and Arthur Funnell for their invaluable guidance and their exceptional teamwork in maintaining a strong data science infrastructure at UCLA CTSI. Their leadership and support have helped foster the kind of collaborative environment that makes work like this possible. Additional thanks to all who offered guidance and encouragement throughout the development of this library. This project reflects a shared commitment to knowledge sharing, teamwork, and advancing model evaluation practices.
## ⚖️ License
`model_metrics` is distributed under the MIT License. See [LICENSE](https://github.com/lshpaner/model_metrics/blob/main/LICENSE.md) for more information.
## ⚓ Support
If you have any questions or issues with `model_metrics`, please open an issue on this [GitHub repository](https://github.com/lshpaner/model_metrics).
## 📚 Citing `model_metrics`
If you use `model_metrics` in your research or projects, please consider citing it.
```bibtex
@software{shpaner_2025_14879819,
author = {Shpaner, Leonid},
title = {Model Metrics},
month = feb,
year = 2025,
publisher = {Zenodo},
version = {0.0.5a6},
doi = {10.5281/zenodo.14879819},
url = {https://doi.org/10.5281/zenodo.14879819}
}
```
| text/markdown | Leonid Shpaner | Leonid Shpaner <lshpaner@ucla.edu> | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | >=3.7.4 | [] | [] | [] | [
"matplotlib<3.11,>=3.5.3",
"numpy<2.2,>=1.21.6",
"pandas<2.3,>=1.3.5",
"plotly<5.25,>=5.18.0",
"scikit-learn<1.6,>=1.0.2",
"scipy<=1.14.0,>=1.8",
"statsmodels<0.15,>=0.13",
"shap<0.47,>=0.41.0",
"tqdm<4.68,>=4.66.4"
] | [] | [] | [] | [
"Source Code, https://github.com/lshpaner/model_metrics",
"Leonid Shpaner's Website, https://www.leonshpaner.com"
] | twine/6.2.0 CPython/3.14.2 | 2026-02-21T04:03:50.047823 | model_metrics-0.0.5a6.tar.gz | 55,089 | c2/5b/9fe81bff9d05d02ca4dc2c1fd9a37283f39eb70510a1b0abce1c5440b579/model_metrics-0.0.5a6.tar.gz | source | sdist | null | false | 878e64bfdde4c46c9c5b929394372fd1 | 5dbf3fbd48185a24766f3e15287e1f46796d452134fb55389ca0e932124fa3c6 | c25b9fe81bff9d05d02ca4dc2c1fd9a37283f39eb70510a1b0abce1c5440b579 | null | [
"LICENSE.md"
] | 208 |
2.4 | pyship | 0.5.0 | freezer, installer and updater for Python applications | # PyShip
[](https://github.com/jamesabel/pyship/actions/workflows/ci.yml)
[](https://codecov.io/gh/jamesabel/pyship)
Enables shipping a python application to end users.
## PyShip's Major Features
* Freeze practically any Python application
* Creates an installer
* Uploads application installer and updates to the cloud
* Automatic application updating in the background (no user intervention)
* OS native application (e.g. .exe for Windows)
* Run on OS startup option
## Documentation and Examples
[Learn PyShip By Example](https://github.com/jamesabel/pyshipexample)
[Short video on pyship given at Pyninsula](https://abelpublic.s3.us-west-2.amazonaws.com/pyship_pyninsula_10_2020.mkv)
## Configuration
pyship settings can be configured in your project's `pyproject.toml` under `[tool.pyship]`. Most settings can also be overridden via CLI arguments (CLI takes precedence).
### pyproject.toml
```toml
[tool.pyship]
# App metadata
is_gui = false # true if the app is a GUI application (default: false)
run_on_startup = false # true to run the app on OS startup (default: false)
# Cloud upload settings
profile = "default" # AWS IAM profile for S3 uploads
upload = true # upload installer and clip to S3 (default: true)
public_readable = false # make uploaded S3 objects publicly readable (default: false)
```
### CLI Arguments
| Argument | pyproject.toml key | Description |
|----------|-------------------|-------------|
| `-p`, `--profile` | `profile` | AWS IAM profile for S3 uploads |
| `--noupload` | `upload` | Disable cloud upload (CLI flag inverts the toml boolean) |
| `--public-readable` | `public_readable` | Make uploaded S3 objects publicly readable |
| `-i`, `--id` | *(CLI only)* | AWS Access Key ID |
| `-s`, `--secret` | *(CLI only)* | AWS Secret Access Key |
`--id` and `--secret` are intentionally CLI-only since `pyproject.toml` is typically version-controlled.
## Testing
Run tests with:
```batch
venv\Scripts\python.exe -m pytest test_pyship/ -v
```
### Environment Variables
| Variable | Description | Default |
|----------|-------------|---------|
| `AWSIMPLE_USE_MOTO_MOCK` | Set to `0` to use real AWS instead of [moto](https://github.com/getmoto/moto) mock. Required for `test_f_update` which tests cross-process S3 updates. Requires valid AWS credentials configured. | `1` (use moto) |
| `MAKE_NSIS_PATH` | Path to the NSIS `makensis.exe` executable. | `C:\Program Files (x86)\NSIS\makensis.exe` |
### Test Modes
- **Default (moto mock)**: All tests run with mocked AWS S3. No credentials needed. `test_f_update` is skipped.
- **Real AWS** (`AWSIMPLE_USE_MOTO_MOCK=0`): All tests run against real AWS S3. `test_f_update` runs and tests cross-process updates.
| text/markdown | null | abel <j@abel.co> | null | null | null | freezer, installer, ship | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"setuptools",
"wheel",
"ismain",
"balsa",
"requests",
"attrs",
"typeguard",
"toml",
"semver",
"python-dateutil",
"wheel-inspect",
"boto3",
"awsimple",
"platformdirs",
"pyshipupdate"
] | [] | [] | [] | [
"Homepage, https://github.com/jamesabel/pyship",
"Download, https://github.com/jamesabel/pyship"
] | twine/6.2.0 CPython/3.14.3 | 2026-02-21T04:03:35.010937 | pyship-0.5.0-py3-none-any.whl | 44,644 | 07/b6/7e0120d1c1722edd77965bfed1d178a1214ff2529c27a4e3efe0c76838c7/pyship-0.5.0-py3-none-any.whl | py3 | bdist_wheel | null | false | 9cd7ce917c6a29b7d2332e0240e29168 | 4fbbda0ac67b85ff88b33ce0237056b134ed21364e90b0d27b82ed3780370419 | 07b67e0120d1c1722edd77965bfed1d178a1214ff2529c27a4e3efe0c76838c7 | MIT | [
"LICENSE"
] | 85 |
2.4 | EDcoder | 0.1.3 | text encoder/decoder using custom table | ...
This is a simple, custom en/decoder
| text/markdown | null | gimminjun <gimminjun163@gmail.com> | null | null | MIT | null | [] | [] | null | null | >=3.7 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.9 | 2026-02-21T04:03:16.957350 | edcoder-0.1.3.tar.gz | 1,661 | 0c/f9/c74c0c9959bcfb1598cc297cf33591fb9f1089ff404eada90b4c9edf3104/edcoder-0.1.3.tar.gz | source | sdist | null | false | 1650c0181a6096cdce2a9271e806f841 | b33c286deb72a9629665dfc441ec2287e6104b3b0f60b397d0855e5f3ca89f3d | 0cf9c74c0c9959bcfb1598cc297cf33591fb9f1089ff404eada90b4c9edf3104 | null | [] | 0 |
2.4 | mlx-audio-io | 1.1.0 | Native audio I/O for MLX on macOS and Linux | # mlx-audio-io
`mlx-audio-io` is the audio data layer for [MLX](https://github.com/ml-explore/mlx): fast file decode/encode directly to and from `mlx.core.array`, with one API across macOS and Linux.
## Why This Project Exists
MLX has strong tensor and model primitives, but it does not ship a first-class, cross-platform audio file I/O layer comparable to what `torchaudio` provides in the PyTorch ecosystem.
In practice, MLX users often end up with one of these compromises:
- bridge through NumPy/SoundFile/librosa with extra copies and inconsistent format behavior
- shell out to `ffmpeg`/`ffprobe` for non-WAV workflows
- pull in parts of the PyTorch audio stack just to handle common audio containers/codecs
`mlx-audio-io` closes that gap with a native backend designed for MLX workloads:
- direct decode/encode into `mlx.core.array`
- one Python API (`load`, `save`, `info`, `stream`, `batch_load`) on both macOS and Linux
- consistent validation and error messages across platforms
- support for training/inference data access patterns (partial reads, chunked streaming, optional resampling)
## Platform Backends
- macOS backend optimized for Apple Silicon via AudioToolbox
- Linux backend with native WAV/MP3 fast paths plus libav-backed codec support (FLAC/M4A/AIFF/CAF)
The public Python API is the same on both platforms: `load`, `save`, `info`, `stream`, `batch_load`.
## Backend Feature Matrix
| Capability | macOS backend | Linux backend |
|---|---|---|
| `info(path)` | AudioToolbox-supported formats (WAV, MP3, M4A/AAC, FLAC, AIFF, CAF, etc.) | WAV, MP3, FLAC, M4A/AAC, AIFF, CAF |
| `load(path)` | AudioToolbox-supported formats + native-rate MP3 fast path | WAV, MP3, FLAC, M4A/AAC, AIFF, CAF |
| `load(..., sr=...)` | Supported, with AudioToolbox resampling | Supported (`WAV/MP3` native linear path, other supported formats via libav decode/resample) |
| `save(path, ...)` | WAV, MP3, M4A/AAC, FLAC, AIFF, CAF | WAV, MP3, M4A/AAC, FLAC, AIFF, CAF |
| `encoding` | `float32`, `pcm16`, `alac` (for `.m4a`) | `float32`, `pcm16`, `alac` (for `.m4a`) |
| `stream(path, ...)` | AudioToolbox-supported formats + native-rate MP3 path | WAV, MP3, FLAC, M4A/AAC, AIFF, CAF |
| `stream(..., sr=...)` | Supported | Supported (`WAV/MP3` native linear path, other supported formats via libav-backed chunked decode path) |
Unsupported format/encoding combinations fail with explicit `ValueError` messages.
## Installation
### End users (PyPI)
For normal use:
```bash
pip install mlx-audio-io
```
### Contributors (source checkout)
For local development and tests:
```bash
git clone https://github.com/ssmall256/mlx-audio-io.git
cd mlx-audio-io
uv sync --extra dev
```
### Linux source build behavior
Linux source builds require libav and use direct libav-backed paths:
- Linux `info()` for non-WAV formats uses direct libav metadata.
- Linux `load()` for non-WAV formats uses direct libav decode for all `offset`/`duration` combinations.
- Linux `stream()` for non-WAV formats uses direct libav packet/frame decode.
- Linux `save()` for encoded formats (`.mp3`, `.flac`, `.m4a`, `.aiff/.aif`, `.caf`) uses direct libav encode/mux.
### Requirements
- Python 3.10+
- Runtime:
- macOS: Apple Silicon + `mlx`
- Linux: `mlx[cpu]` (current default)
- Source builds:
- CMake 3.24+, C++17 toolchain, `pkg-config`
- Linux default build: `libavformat-dev`, `libavcodec-dev`, `libavutil-dev`, `libswresample-dev`
### Linux Troubleshooting
- `ModuleNotFoundError: mlx_audio_io`
- Install in the project environment (`uv sync`) and run via `uv run ...`.
- `ImportError` for `mlx` on Linux
- Ensure Linux dependency is installed as `mlx[cpu]`.
- Build failures on source installs
- Verify `build-essential`, `cmake`, `ninja-build`, and `pkg-config` are installed.
- Extended Linux format support errors (`.mp3`, `.m4a`, `.flac`, `.aiff`, `.caf`)
- For default Linux builds, ensure runtime libav libraries are present (`libavformat`, `libavcodec`, `libavutil`, `libswresample`).
- MP3 test fixture generation failures
- Tests that generate MP3 fixtures require `ffmpeg` or `lame` available on `PATH`.
## Quickstart
```python
from mlx_audio_io import load, save, info, stream, batch_load
# Load
x, sr = load("speech.wav")
# Resample + mono
x16, sr16 = load("speech.wav", sr=16000, mono=True)
# Metadata without decoding
meta = info("speech.wav")
# Stream in chunks
for chunk, chunk_sr in stream("long.wav", chunk_duration=2.0):
pass
# Save WAV
save("out.wav", x, sr)
save("out_pcm16.wav", x, sr, encoding="pcm16")
# Batch load
items = batch_load(["a.wav", "b.wav"], sr=16000, mono=True)
```
Additional save examples:
```python
save("out.flac", x, sr)
save("out.mp3", x, sr, bitrate="192k")
save("out.m4a", x, sr, bitrate="256k")
save("out.m4a", x, sr, encoding="alac")
```
## API Reference
### `load`
```python
load(path, sr=None, offset=0.0, duration=None, mono=False,
layout="channels_last", dtype="float32", resample_quality="default")
```
Decode audio into an `mlx.core.array`. Returns `(audio, sample_rate)`.
| Parameter | Default | Description |
|---|---|---|
| `path` | — | Path to audio file |
| `sr` | `None` | Target sample rate; `None` keeps native rate |
| `offset` | `0.0` | Start position in seconds |
| `duration` | `None` | Duration in seconds; `None` reads to end |
| `mono` | `False` | Mix down to mono |
| `layout` | `"channels_last"` | `"channels_last"` `[frames, ch]` or `"channels_first"` `[ch, frames]` |
| `dtype` | `"float32"` | `"float32"` or `"float16"` |
| `resample_quality` | `"default"` | `"default"`, `"fastest"`, `"low"`, `"medium"`, `"high"`, `"best"` |
> On Linux WAV/MP3 fast paths, resample quality levels currently map to the same linear behavior.
### `batch_load`
```python
batch_load(paths, sr=None, mono=False, dtype="float32", num_workers=4)
```
Threaded multi-file `load()`. Returns `list[(audio, sample_rate)]`.
### `save`
```python
save(path, audio, sr, layout="channels_last", encoding="float32",
bitrate="auto", clip=True)
```
Write audio from `mx.array` (or `numpy.ndarray`) to disk.
| Parameter | Default | Description |
|---|---|---|
| `path` | — | Output file path (format inferred from extension) |
| `audio` | — | Audio data; 1-D input is treated as mono |
| `sr` | — | Sample rate |
| `layout` | `"channels_last"` | Layout of the input array |
| `encoding` | `"float32"` | `"float32"`, `"pcm16"`, or `"alac"` (for `.m4a`) |
| `bitrate` | `"auto"` | Bitrate for lossy formats (`.m4a` AAC, `.mp3` on Linux) |
| `clip` | `True` | Clamp samples to `[-1, 1]` before encoding |
### `stream`
```python
stream(path, chunk_frames=None, chunk_duration=None, sr=None,
mono=False, dtype="float32")
```
Return an iterator yielding `(audio_chunk, sample_rate)`. Exactly one of `chunk_frames` or `chunk_duration` is required.
| Parameter | Default | Description |
|---|---|---|
| `path` | — | Path to audio file |
| `chunk_frames` | `None` | Chunk size in frames |
| `chunk_duration` | `None` | Chunk size in seconds |
| `sr` | `None` | Target sample rate; `None` keeps native rate |
| `mono` | `False` | Mix down to mono |
| `dtype` | `"float32"` | `"float32"` or `"float16"` |
### `info`
```python
info(path)
```
Return `AudioInfo` metadata without decoding sample buffers.
| Field | Description |
|---|---|
| `frames` | Total number of sample frames |
| `sample_rate` | Sample rate in Hz |
| `channels` | Number of channels |
| `duration` | Duration in seconds |
| `subtype` | Sample encoding (e.g. `pcm16`, `float32`) |
| `container` | File format (e.g. `wav`, `mp3`, `m4a`) |
## Testing
Run all tests:
```bash
uv sync --extra dev
uv run python -m pytest -q
```
Run Linux supported subset:
```bash
uv run python -m pytest -q -m "not apple_only"
```
Run Apple-only subset:
```bash
uv run python -m pytest -q -m "apple_only"
```
Linux Docker run from a macOS host:
```bash
docker run --rm -it --platform linux/arm64 \
-v "$PWD":/work -w /work \
python:3.14-bookworm bash -lc '
apt-get update && apt-get install -y --no-install-recommends \
build-essential cmake ninja-build pkg-config ffmpeg \
libavformat-dev libavcodec-dev libavutil-dev libswresample-dev &&
python -m pip install -U pip uv &&
uv sync --extra dev &&
uv run python -m pytest -q -m "not apple_only"
'
```
## Performance
Benchmark methodology, commands, and full result tables live in [`docs/benchmarking.md`](docs/benchmarking.md).
Headline numbers (194.8s stereo PCM16 WAV @ 44.1 kHz, p50 median latency):
| Task | macOS M4 Max | Linux arm64 |
|---|---|---|
| Full WAV load | **3.59 ms** — 6.9x faster than librosa | **8.41 ms** — 5.9x faster than librosa |
| WAV partial read (1 s) | **0.04 ms** — 3.4x faster than librosa | **0.05 ms** — 2.6x faster than librosa |
| WAV save (float32) | **6.98 ms** — 2.8x faster than soundfile | **31.70 ms** — 1.8x faster than soundfile |
| MP3 load (native SR) | **63.70 ms** — 1.3x faster than librosa | **80.93 ms** — on par with librosa |
| M4A/AAC load | **56.31 ms** — 2.2x faster than librosa | **89.63 ms** — 1.6x faster than librosa |
| Load + resample 16 kHz | **13.12 ms** — 4.4x faster than librosa | **10.93 ms** — 7.9x faster than librosa |
Full tables with torchaudio comparisons, M1 Max, and Linux x86_64 results are in the benchmarking doc.
## License
MIT
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"mlx==0.30.6; platform_system == \"Darwin\"",
"mlx[cpu]==0.30.6; platform_system == \"Linux\"",
"pytest>=9.0.2",
"pytest; extra == \"dev\"",
"librosa; extra == \"benchmark\"",
"soundfile; extra == \"benchmark\"",
"numpy; extra == \"benchmark\"",
"psutil; extra == \"benchmark\"",
"torch; extra == \"benchmark\"",
"torchaudio; extra == \"benchmark\"",
"torchcodec; (platform_system != \"Linux\" or (platform_machine != \"aarch64\" and platform_machine != \"arm64\")) and extra == \"benchmark\""
] | [] | [] | [] | [
"Repository, https://github.com/ssmall256/mlx-audio-io",
"Issues, https://github.com/ssmall256/mlx-audio-io/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:01:57.104154 | mlx_audio_io-1.1.0.tar.gz | 287,525 | 12/20/caf789e5c8e10379df58f2e95f5c5a2f8c2776febce713f905f14959744c/mlx_audio_io-1.1.0.tar.gz | source | sdist | null | false | 920a860cef14feafc8020c43c2dd225d | 5d161345c0b7cc04bec04e7f078a44740038d76ea420d32f0946109676811521 | 1220caf789e5c8e10379df58f2e95f5c5a2f8c2776febce713f905f14959744c | MIT | [] | 175 |
2.4 | mcp-gemini-crunchtools | 0.1.0 | MCP server for Google Gemini AI - text, image, video, research, and more | # MCP Gemini CrunchTools
A secure MCP (Model Context Protocol) server for Google Gemini AI - text, image, video, research, and more.
## Overview
This MCP server is designed to be:
- **Secure by default** - Comprehensive threat modeling, input validation, and API key protection
- **No third-party services** - Runs locally via stdio, your API key never leaves your machine
- **Cross-platform** - Works on Linux, macOS, and Windows
- **Automatically updated** - GitHub Actions monitor for CVEs and update dependencies
- **Containerized** - Available at `quay.io/crunchtools/mcp-gemini` built on [Hummingbird Python](https://quay.io/repository/hummingbird/python) base image
## Naming Convention
| Component | Name |
|-----------|------|
| GitHub repo | [crunchtools/mcp-gemini](https://github.com/crunchtools/mcp-gemini) |
| Container | `quay.io/crunchtools/mcp-gemini` |
| Python package (PyPI) | `mcp-gemini-crunchtools` |
| CLI command | `mcp-gemini-crunchtools` |
| Module import | `mcp_gemini_crunchtools` |
## Why Hummingbird?
The container image is built on the [Hummingbird Python base image](https://quay.io/repository/hummingbird/python) from [Project Hummingbird](https://github.com/hummingbird-project), which provides:
- **Minimal CVE exposure** - Hummingbird images are built with a minimal package set, dramatically reducing the attack surface compared to general-purpose images
- **Regular updates** - Security patches are applied promptly, keeping CVE counts low
- **Optimized for Python** - Pre-configured Python environment with uv package manager for fast, reproducible builds
- **Production-ready** - Designed for production workloads with proper signal handling and non-root user defaults
This means your MCP server runs in a hardened environment with fewer vulnerabilities than typical Python container images.
## Features
### Query Tools (5 tools)
- `gemini_query` - Query Gemini with optional Google Search grounding
- `gemini_brainstorm` - Generate creative ideas on a topic
- `gemini_analyze_code` - Analyze code for security, performance, bugs
- `gemini_analyze_text` - Analyze text for sentiment, tone, content
- `gemini_summarize` - Summarize content in various formats
### Image Generation (4 tools)
- `gemini_generate_image` - Generate images from text prompts (native Gemini)
- `gemini_generate_image_with_input` - Edit/modify existing images
- `gemini_image_prompt` - Craft effective image generation prompts
- `gemini_imagen_generate` - Generate images using Google Imagen 4 models
### Image Editing (4 tools)
- `gemini_start_image_edit` - Start a multi-turn image editing session
- `gemini_continue_image_edit` - Continue editing in an active session
- `gemini_end_image_edit` - End an image editing session
- `gemini_list_image_sessions` - List all active editing sessions
### Image Analysis (1 tool)
- `gemini_analyze_image` - Analyze and describe local image files
### Search Tools (1 tool)
- `gemini_search` - Web search using Gemini with Google Search grounding
### Document Tools (3 tools)
- `gemini_analyze_document` - Analyze PDFs, DOCX, TXT, etc.
- `gemini_summarize_pdf` - Summarize PDF documents
- `gemini_extract_tables` - Extract tables from documents
### URL Tools (3 tools)
- `gemini_analyze_url` - Analyze one or more URLs
- `gemini_compare_urls` - Compare two URLs
- `gemini_extract_from_url` - Extract specific data from a URL
### Video Tools (2 tools)
- `gemini_generate_video` - Generate videos using Veo
- `gemini_check_video` - Check video generation status
### YouTube Tools (2 tools)
- `gemini_youtube` - Analyze YouTube videos
- `gemini_youtube_summary` - Summarize YouTube videos
### Voice Tools (3 tools)
- `gemini_speak` - Convert text to speech
- `gemini_dialogue` - Generate multi-voice dialogue audio
- `gemini_list_voices` - List available voices
### Research Tools (3 tools)
- `gemini_deep_research` - Perform multi-step web research
- `gemini_check_research` - Check research operation status
- `gemini_research_followup` - Ask follow-up questions
### Cache Tools (4 tools)
- `gemini_create_cache` - Create content cache for repeated queries
- `gemini_query_cache` - Query cached content
- `gemini_list_caches` - List all active caches
- `gemini_delete_cache` - Delete a cache
### Structured Output Tools (2 tools)
- `gemini_structured` - Get structured JSON output
- `gemini_extract` - Extract structured data from text
### Token Tools (1 tool)
- `gemini_count_tokens` - Count tokens in content
### Code Execution Tools (1 tool)
- `gemini_run_code` - Execute Python code via Gemini
**Total: 39 tools**
## Installation
### With uvx (Recommended)
```bash
uvx mcp-gemini-crunchtools
```
### With pip
```bash
pip install mcp-gemini-crunchtools
```
### With Container
```bash
podman run -e GEMINI_API_KEY=your_key \
quay.io/crunchtools/mcp-gemini
```
## Configuration
### Creating a Google Gemini API Key
1. **Navigate to Google AI Studio**
- Go to https://aistudio.google.com/apikey
- Sign in with your Google account
2. **Create API Key**
- Click "Get API key" or "Create API key"
- Select a Google Cloud project or create a new one
- Click "Create API key in new project" (or select existing project)
3. **Copy Your API Key**
- **IMPORTANT: Copy the API key immediately** - store it securely!
- The key starts with `AI...` (e.g., `AIzaSy...`)
### Add to Claude Code
```bash
claude mcp add mcp-gemini-crunchtools \
--env GEMINI_API_KEY=your_api_key_here \
-- uvx mcp-gemini-crunchtools
```
Or for the container version:
```bash
claude mcp add mcp-gemini-crunchtools \
--env GEMINI_API_KEY=your_api_key_here \
-- podman run -i --rm -e GEMINI_API_KEY quay.io/crunchtools/mcp-gemini
```
### Optional: Set Output Directory
For generated images, audio, and videos:
```bash
claude mcp add mcp-gemini-crunchtools \
--env GEMINI_API_KEY=your_api_key_here \
--env GEMINI_OUTPUT_DIR=$HOME/.config/mcp-gemini-crunchtools/output \
-- uvx mcp-gemini-crunchtools
```
## Usage Examples
### Query with Google Search
```
User: What are the latest developments in quantum computing?
Assistant: [calls gemini_query with use_google_search=true]
```
### Generate an Image
```
User: Generate a photorealistic image of a sunset over mountains
Assistant: [calls gemini_generate_image with prompt and style]
```
### Analyze a PDF Document
```
User: Analyze this research paper at /path/to/paper.pdf
Assistant: [calls gemini_analyze_document with file_path]
```
### Summarize a YouTube Video
```
User: Summarize this YouTube video: https://youtube.com/watch?v=...
Assistant: [calls gemini_youtube_summary with url]
```
### Deep Research
```
User: Research the environmental impact of electric vehicles
Assistant: [calls gemini_deep_research then gemini_check_research]
```
### Code Analysis
```
User: Analyze this Python code for security issues
Assistant: [calls gemini_analyze_code with focus="security"]
```
## Security
This server was designed with security as a primary concern. See [SECURITY.md](SECURITY.md) for:
- Threat model and attack vectors
- Defense in depth architecture
- API key handling best practices
- Input validation rules
- Audit logging
### Key Security Features
1. **API Key Protection**
- Stored as SecretStr (never accidentally logged)
- Environment variable only (never in files or args)
- Sanitized from all error messages
2. **Input Validation**
- Pydantic models for all inputs
- File path validation
- URL validation
- Strict format validation
3. **API Hardening**
- Hardcoded API base URL (prevents SSRF)
- TLS certificate validation
- Request timeouts
- Response size limits
4. **Automated CVE Scanning**
- GitHub Actions scan dependencies weekly
- Automatic PRs for security updates
- Dependabot alerts enabled
## Development
### Setup
```bash
git clone https://github.com/crunchtools/mcp-gemini.git
cd mcp-gemini
uv sync
```
### Run Tests
```bash
uv run pytest
```
### Lint and Type Check
```bash
uv run ruff check src tests
uv run mypy src
```
### Build Container
```bash
podman build -t mcp-gemini .
```
## License
AGPL-3.0-or-later
## Contributing
Contributions welcome! Please read SECURITY.md before submitting security-related changes.
## Links
- [Google Gemini API Documentation](https://ai.google.dev/docs)
- [Google AI Studio](https://aistudio.google.com/)
- [FastMCP Documentation](https://gofastmcp.com/)
- [MCP Specification](https://modelcontextprotocol.io/)
- [crunchtools.com](https://crunchtools.com)
| text/markdown | crunchtools.com | null | null | null | null | fastmcp, gemini, google-ai, imagen, mcp | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"fastmcp>=2.0",
"google-genai>=1.34",
"pillow>=10.0",
"pydantic>=2.0",
"mypy>=1.13; extra == \"dev\"",
"pytest-asyncio>=0.24; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.8; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:01:41.028531 | mcp_gemini_crunchtools-0.1.0.tar.gz | 43,138 | f1/d0/498e39b58ac329181d2cb5f5e911eaff0e09a0dc1649d5a6979d24548c73/mcp_gemini_crunchtools-0.1.0.tar.gz | source | sdist | null | false | dc07446f5745a8d2dfbf82544c95d1e1 | 020aac921e13a91f3187cc20d415cc057445f95db4c89bb48285da581a2c9545 | f1d0498e39b58ac329181d2cb5f5e911eaff0e09a0dc1649d5a6979d24548c73 | AGPL-3.0-or-later | [
"LICENSE"
] | 236 |
2.4 | ouro-ai | 0.2.4 | General AI Agent System | <div align="center">
<img alt="OURO" src="docs/assets/logo.png" width="440">
[](https://pypi.org/project/ouro-ai/)
[](LICENSE)
[]()
*An open-source AI agent built on a single, unified loop.*
</div>
Ouro is derived from Ouroboros—the ancient symbol of a serpent consuming its own tail to form a perfect circle. It represents the ultimate cycle: a closed loop of self-consumption, constant renewal, and infinite iteration.
At Ouro AI Lab, this is our blueprint. We are building the next generation of AI agents capable of autonomous evolution—systems that learn from their own outputs, refine their own logic, and achieve a state of infinite self-improvement.
## Installation
Prerequisites: Python 3.12+.
```bash
pip install ouro-ai
```
Or install from source (for development):
```bash
git clone https://github.com/ouro-ai-labs/ouro.git
cd ouro
./scripts/bootstrap.sh # requires uv
```
## Quick Start
### 1. Configure Models
On first run, `~/.ouro/models.yaml` is created with a template. Edit it to add your provider and API key:
```yaml
models:
openai/gpt-4o:
api_key: sk-...
anthropic/claude-sonnet-4:
api_key: sk-ant-...
chatgpt/gpt-5.2-codex:
timeout: 600
ollama/llama2:
api_base: http://localhost:11434
default: openai/gpt-4o
current: openai/gpt-4o
```
For `chatgpt/*` subscription models, run `ouro --login` (or `/login` in interactive mode) and select provider before use.
OAuth models shown in `/model` are seeded from ouro's bundled catalog (synced from pi-ai `openai-codex` model list).
Maintainer note: refresh this catalog via `python scripts/update_oauth_model_catalog.py`.
Login uses a browser-based OAuth (PKCE) flow with a localhost callback server. If browser auto-open fails, ouro prints a URL you can open manually (for remote machines, SSH port-forwarding may be required).
Advanced OAuth overrides (rarely needed) are documented in `docs/configuration.md`.
See [LiteLLM Providers](https://docs.litellm.ai/docs/providers) for the full list.
### 2. Run
```bash
# Interactive mode
ouro
# Single task (returns raw result)
ouro --task "Calculate 123 * 456"
# Resume last session
ouro --resume
# Resume specific session (ID prefix)
ouro --resume a1b2c3d4
```
## CLI Reference
| Flag | Short | Description |
|------|-------|-------------|
| `--task TEXT` | `-t` | Run a single task and exit |
| `--model ID` | `-m` | LiteLLM model ID to use |
| `--resume [ID]` | `-r` | Resume a session (`latest` if no ID given) |
| `--login` | - | Open OAuth provider selector and login |
| `--logout` | - | Open OAuth provider selector and logout |
| `--verify` | | Enable self-verification (Ralph Loop) in `--task` mode |
| `--reasoning-effort LEVEL` | - | Set run-scoped reasoning effort (`default|none|minimal|low|medium|high|xhigh|off`) |
| `--verbose` | `-v` | Enable verbose logging to `~/.ouro/logs/` |
## Interactive Commands
### Slash Commands
| Command | Description |
|---------|-------------|
| `/help` | Show help |
| `/reset` | Clear conversation and start fresh |
| `/stats` | Show memory and token usage statistics |
| `/resume [id]` | List or resume a previous session |
| `/model` | Pick a model (arrow keys + Enter) |
| `/model edit` | Open `~/.ouro/models.yaml` in editor (auto-reload on save) |
| `/login` | Open OAuth provider selector and login |
| `/logout` | Open OAuth provider selector and logout |
| `/theme` | Toggle dark/light theme |
| `/verbose` | Toggle thinking display |
| `/reasoning` | Open reasoning menu |
| `/compact` | Trigger memory compression and show token savings |
| `/exit` | Exit (also `/quit`) |
### Keyboard Shortcuts
| Key | Action |
|-----|--------|
| `/` | Command autocomplete |
| `Ctrl+C` | Graceful interrupt (cancels current operation, rolls back incomplete memory) |
| `Ctrl+L` | Clear screen |
| `Ctrl+T` | Toggle thinking display |
| `Ctrl+S` | Show quick stats |
| Up/Down | Navigate command history |
## Features
- **Unified agent loop**: Think-Act-Observe cycle — planning, sub-agents, and tool use all happen in one loop, chosen autonomously by the agent
- **Self-verification**: Ralph Loop verifies the agent's answer against the original task and re-enters if incomplete (`--verify`)
- **Parallel execution**: Concurrent readonly tool calls in a single turn, plus `multi_task` for spawning parallel sub-agents with dependency ordering
- **Memory system**: LLM-driven compression (sliding window / selective / deletion), git-aware long-term memory, and YAML session persistence resumable via `--resume`
- **OAuth login**: `--login` / `/login` to authenticate with ChatGPT Codex subscription models; bundled OAuth catalog auto-synced
- **TUI**: Dark/light themes, slash-command autocomplete, live status bar, token & cache tracking (`/stats`)
- **Skills**: Extensible skill registry — list, install, and manage via `/skills`
- **Benchmarks**: First-class [Harbor](https://github.com/laude-institute/harbor) integration for agent evaluation (see [Evaluation](#evaluation))
## Evaluation
Ouro can be evaluated on agent benchmarks using [Harbor](https://github.com/laude-institute/harbor). A convenience script `harbor-run.sh` is provided at the repo root:
1. Edit `harbor-run.sh` to set your model, dataset, and ouro version.
2. Run:
```bash
export OURO_API_KEY=<your-api-key>
./harbor-run.sh # run with defaults in the script
./harbor-run.sh -l 5 # limit to 5 tasks
./harbor-run.sh --n-concurrent 4 # 4 parallel workers
```
Extra flags are forwarded to `harbor run`, so any Harbor CLI option works. See [ouro_harbor/README.md](ouro_harbor/README.md) for full details.
## Configuration
See [Configuration Guide](docs/configuration.md) for all settings.
## Documentation
- [Configuration](docs/configuration.md) -- model setup, runtime settings, custom endpoints
- [Examples](docs/examples.md) -- usage patterns and programmatic API
- [Memory Management](docs/memory-management.md) -- compression, persistence, token tracking
- [Extending](docs/extending.md) -- adding tools, agents, LLM providers
- [Packaging](docs/packaging.md) -- building, publishing, Docker
## Contributing
Contributions are welcome! Please open an [issue](https://github.com/ouro-ai-labs/ouro/issues) or submit a pull request.
For development setup, see the [Installation](#installation) section (install from source).
## License
MIT License
| text/markdown | null | luohaha <luoyixin6688@gmail.com> | null | null | MIT | ai, agent, llm, claude, gpt, gemini, loop, planning | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"ddgs>=1.0.0",
"rich>=13.0.0",
"prompt_toolkit>=3.0.0",
"httpx>=0.28.0",
"authlib>=1.3.0",
"trafilatura>=2.0.0",
"lxml>=5.0.0",
"aiofiles>=24.1.0",
"litellm<2.0,>=1.81.1",
"PyYAML>=6.0",
"tiktoken>=0.5.0",
"tenacity>=8.2.0",
"tree-sitter>=0.24.0",
"tree-sitter-javascript>=0.23.0",
"tree-sitter-typescript>=0.23.0",
"tree-sitter-go>=0.23.0",
"tree-sitter-rust>=0.23.0",
"tree-sitter-java>=0.23.0",
"tree-sitter-kotlin>=1.1.0",
"tree-sitter-c>=0.23.0",
"tree-sitter-cpp>=0.23.0",
"croniter>=1.3.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-asyncio>=0.24.0; extra == \"dev\"",
"black==25.1.0; extra == \"dev\"",
"isort==6.0.0; extra == \"dev\"",
"mypy>=1.0.0; extra == \"dev\"",
"ruff==0.9.10; extra == \"dev\"",
"pre-commit>=3.0.0; extra == \"dev\"",
"types-aiofiles>=25.1.0; extra == \"dev\"",
"types-croniter>=1.3.0; extra == \"dev\"",
"types-PyYAML>=6.0; extra == \"dev\"",
"harbor>=0.1.0; extra == \"harbor\""
] | [] | [] | [] | [
"Homepage, https://github.com/ouro-ai-labs/ouro",
"Documentation, https://github.com/ouro-ai-labs/ouro#readme",
"Repository, https://github.com/ouro-ai-labs/ouro",
"Issues, https://github.com/ouro-ai-labs/ouro/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:01:19.093565 | ouro_ai-0.2.4.tar.gz | 184,704 | 8c/6c/35b3caada610e06f8c7d0e24feaf525061ccba22f6c8bff48a2bf8b7b274/ouro_ai-0.2.4.tar.gz | source | sdist | null | false | ef413bc149834ffdd4177bad86828cd4 | 423c53f3d47f64713937e2f2bb29d73143e41095c89c8e9fff3c2b83299dfe03 | 8c6c35b3caada610e06f8c7d0e24feaf525061ccba22f6c8bff48a2bf8b7b274 | null | [
"LICENSE"
] | 220 |
2.4 | keras-rs-nightly | 0.4.1.dev202602210400 | Multi-backend recommender systems with Keras 3. | # Keras Recommenders
<p align="center" width="100%">
<img src="https://i.imgur.com/m1BX7Zd.png" width="434" height="157" alt="KerasRS">
</p>
Keras Recommenders is a library for building recommender systems on top of
Keras 3. Keras Recommenders works natively with TensorFlow, JAX, or PyTorch. It
provides a collection of building blocks which help with the full workflow of
creating a recommender system. As it's built on Keras 3, models can be trained
and serialized in any framework and re-used in another without costly
migrations.
This library is an extension of the core Keras API; all high-level modules
receive that same level of polish as core Keras. If you are familiar with Keras,
congratulations! You already understand most of Keras Recommenders.
## Quick Links
- [Home page](https://keras.io/keras_rs)
- [Examples](https://keras.io/keras_rs/examples)
- [API documentation](https://keras.io/keras_rs/api)
## Quickstart
### Train your own cross network
Choose a backend:
```python
import os
os.environ["KERAS_BACKEND"] = "jax" # Or "tensorflow" or "torch"!
```
Import KerasRS and other libraries:
```python
import keras
import keras_rs
import numpy as np
```
Define a simple model using the `FeatureCross` layer:
```python
vocabulary_size = 32
embedding_dim = 6
inputs = keras.Input(shape=(), name='indices', dtype="int32")
x0 = keras.layers.Embedding(
input_dim=vocabulary_size,
output_dim=embedding_dim
)(inputs)
x1 = keras_rs.layers.FeatureCross()(x0, x0)
x2 = keras_rs.layers.FeatureCross()(x0, x1)
output = keras.layers.Dense(units=10)(x2)
model = keras.Model(inputs, output)
```
Compile the model:
```python
model.compile(
loss=keras.losses.MeanSquaredError(),
optimizer=keras.optimizers.Adam(learning_rate=3e-4)
)
```
Call `model.fit()` on dummy data:
```python
batch_size = 2
x = np.random.randint(0, vocabulary_size, size=(batch_size,))
y = np.random.random(size=(batch_size,))
model.fit(x, y=y)
```
### Use ranking losses and metrics
If your task is to rank items in a list, you can make use of the ranking losses
and metrics which KerasRS provides. Below, we use the pairwise hinge loss and
track the nDCG metric:
```python
model.compile(
loss=keras_rs.losses.PairwiseHingeLoss(),
metrics=[keras_rs.metrics.NDCG()],
optimizer=keras.optimizers.Adam(learning_rate=3e-4),
)
```
## Installation
Keras Recommenders is available on PyPI as `keras-rs`:
```bash
pip install keras-rs
```
To try out the latest version of Keras Recommenders, you can use our nightly
package:
```bash
pip install keras-rs-nightly
```
Read [Getting started with Keras](https://keras.io/getting_started/) for more
information on installing Keras 3 and compatibility with different frameworks.
> [!IMPORTANT]
> We recommend using Keras Recommenders with TensorFlow 2.16 or later, as
> TF 2.16 packages Keras 3 by default.
## Configuring your backend
If you have Keras 3 installed in your environment (see installation above), you
can use Keras Recommenders with any of JAX, TensorFlow and PyTorch. To do so,
set the `KERAS_BACKEND` environment variable. For example:
```shell
export KERAS_BACKEND=jax
```
Or in Colab, with:
```python
import os
os.environ["KERAS_BACKEND"] = "jax"
import keras_rs
```
> [!IMPORTANT]
> Make sure to set the `KERAS_BACKEND` **before** importing any Keras libraries;
> it will be used to set up Keras when it is first imported.
## Compatibility
We follow [Semantic Versioning](https://semver.org/), and plan to provide
backwards compatibility guarantees both for code and saved models built with our
components. While we continue with pre-release `0.y.z` development, we may break
compatibility at any time and APIs should not be considered stable.
## Citing Keras Recommenders
If Keras Recommenders helps your research, we appreciate your citations.
Here is the BibTeX entry:
```bibtex
@misc{kerasrecommenders2024,
title={KerasRecommenders},
author={Hertschuh, Fabien and Chollet, Fran\c{c}ois and Sharma, Abheesht and others},
year={2024},
howpublished={\url{https://github.com/keras-team/keras-rs}},
}
```
## Acknowledgements
Thank you to all of our wonderful contributors!
<a href="https://github.com/keras-team/keras-rs/graphs/contributors">
<img src="https://contrib.rocks/image?repo=keras-team/keras-rs" />
</a>
| text/markdown | null | Keras team <keras-users@googlegroups.com> | null | null | Apache License 2.0 | null | [
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3 :: Only",
"Operating System :: Unix",
"Operating System :: Microsoft :: Windows",
"Operating System :: MacOS",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering",
"Topic :: Software Development"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"keras",
"ml-dtypes"
] | [] | [] | [] | [
"Home, https://keras.io/keras_rs",
"Repository, https://github.com/keras-team/keras-rs"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T04:01:17.699685 | keras_rs_nightly-0.4.1.dev202602210400.tar.gz | 70,353 | e6/4c/54e6ac8859a6298a34f3f8495398b1793c2ad9a610542081c287e62eef4c/keras_rs_nightly-0.4.1.dev202602210400.tar.gz | source | sdist | null | false | ec7f7e3db7ade6a62e9af7d8926ce18b | f6b2374e3c849e31cd0bb74b3b911c891616e97c12629c3478437c022275b70d | e64c54e6ac8859a6298a34f3f8495398b1793c2ad9a610542081c287e62eef4c | null | [] | 186 |
2.4 | iceberg-mcp-server | 0.1.27 | MCP Server for Apache Iceberg | # iceberg-mcp-server
<!-- mcp-name: io.github.dragonejt/iceberg-mcp-server -->
iceberg-mcp-server is an MCP Server for Apache Iceberg, enabling users to read, query, and manipulate data within Iceberg catalogs. It supports reading and data manipulation using catalog types supported by PyIceberg, and supports SQL queries using catalog types compatible with DuckDB.
## Quickstart
### Installation
With [uv](https://docs.astral.sh/uv/), installation is easy, the only command you need to run is:
```bash
uvx iceberg-mcp-server
```
This will automatically install and run the latest version of iceberg-mcp-server published to PyPI. Alternative Python package runners like `pipx` are also supported. Once installed, iceberg-mcp-server can be used with any agent that supports STDIO-based MCP servers. For example, with OpenAI's Codex CLI `~/.codex/config.toml`:
```toml
[mcp_servers.iceberg]
command = "uvx"
args = ["iceberg-mcp-server"]
```
### Configuration
#### `.pyiceberg.yaml` File
iceberg-mcp-server supports the [PyIceberg configuration methods](https://py.iceberg.apache.org/configuration/). `.pyiceberg.yaml` is the recommended persistent method of configuration. For example, to connect to a standard REST-based Iceberg catalog with `~/.pyiceberg.yaml`:
```yaml
catalog:
default: # iceberg-mcp-server loads the catalog named "default" if not in env vars
uri: <catalog-uri>
token: <catalog-token>
warehouse: <warehouse>
```
#### Environment Variables
One of the other PyIceberg configuration methods is setting specific environment variables, which iceberg-mcp-server supports as well. There are also environment variables specific to iceberg-mcp-server that can be set:
```bash
ICEBERG_CATALOG="default"
SENTRY_DSN="https://<sentry-key>@o<organization-id>.ingest.us.sentry.io/<project-id>"
```
* `ICEBERG_CATALOG` allows you to set which catalog will be loaded. By default, the catalog named `default` will be loaded based on PyIceberg behavior.
* Optionally, you may send telemetry to [Sentry](https://sentry.io/welcome/) by specifying a `SENTRY_DSN`. This will send traces, profiles, logs, and default PII to Sentry, as well as enable the Sentry MCP integration.
## Local Development
### Building and Running
This project uses uv for package management and builds. Once this repository has been cloned, running the local development version of iceberg-mcp-server only requires a single command:
```bash
uv run iceberg-mcp-server
```
An Iceberg catalog still needs to be configured, but then it can be integrated into any agent that supports STDIO-based MCP servers as long as the agent is ran from the repository root directory.
### Testing
This repository uses pytest for test running, although the tests themselves are structured in the unittest format. Running tests involves invoking pytest like any other project. If you use VS Code or a fork for development, the [VS Code Python Extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python) will enable automatic test discovery and running in the Testing sidebar. Tests will also be run with coverage in the [integration workflow](https://github.com/dragonejt/iceberg-mcp-server/blob/main/.github/workflows/integrate.yml).
### Linting and Formatting
iceberg-mcp-server uses [Ruff](https://docs.astral.sh/ruff/) and [ty](https://docs.astral.sh/ty/) for linting, formatting, and type checking. The standard commands to run are:
```bash
ruff check --fix # linting
ruff format # formatting
ty check # type checking
```
The Ruff configuration is found in `pyproject.toml`, and all autofixable issues will be autofixed. If you use VS Code or a fork for development, the [VS Code Ruff Extension](https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff) and [VS Code ty Extension](https://marketplace.visualstudio.com/items?itemName=astral-sh.ty) will enable viewing issues from Ruff and ty within your editor. Additionally, Ruff, ty, and CodeQL analysis will be run in the [integration workflow](https://github.com/dragonejt/iceberg-mcp-server/blob/main/.github/workflows/integrate.yml). | text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: Apache Software License"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"duckdb",
"fastexcel",
"fastmcp[tasks]",
"polars",
"pyarrow",
"pydantic",
"pyiceberg[bigquery,duckdb,dynamodb,glue,hive,polars,pyarrow,pyiceberg-core,sql-postgres,sql-sqlite]",
"sentry-sdk"
] | [] | [] | [] | [
"homepage, https://pypi.org/project/iceberg-mcp-server/",
"source, https://github.com/dragonejt/iceberg-mcp-server.git",
"issues, https://github.com/dragonejt/iceberg-mcp-server/issues",
"documentation, https://github.com/dragonejt/iceberg-mcp-server/wiki"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T03:59:59.254728 | iceberg_mcp_server-0.1.27.tar.gz | 7,282 | 1c/db/4014f648d0e96e9ccabb683ae66beb0be82bb767c5e09ecceeb3532b3eac/iceberg_mcp_server-0.1.27.tar.gz | source | sdist | null | false | 06976551fdbbd9bffde594cc35107bae | c32f2b4f74d2ba761d3c58154cf9a54355a2dc4fa41f90f6e2fc7e1f585116cf | 1cdb4014f648d0e96e9ccabb683ae66beb0be82bb767c5e09ecceeb3532b3eac | Apache-2.0 | [] | 219 |
2.4 | frd-score | 1.0.0 | Fréchet Radiomics Distance (FRD) — a metric for comparing medical image distributions | <!---[](https://pypi.org/project/frd-score/)--->
## NEWS 1/9/26: 🎉 the FRD paper has been accepted to [Medical Image Analysis](https://www.sciencedirect.com/science/article/pii/S1361841526000125) 🎉!
# FRD (Fréchet Radiomic Distance): A Metric Designed for Medical Image Distribution Comparison in the Age of Deep Learning
#### By [Nicholas Konz*](https://nickk124.github.io/), [Richard Osuala*](https://scholar.google.com/citations?user=0KkVRVQAAAAJ&hl=en), (* = equal contribution), [Preeti Verma](https://scholar.google.com/citations?user=6WN41lwAAAAJ&hl=en), [Yuwen Chen](https://scholar.google.com/citations?user=61s49p0AAAAJ&hl=en), [Hanxue Gu](https://scholar.google.com/citations?user=aGjCpQUAAAAJ&hl=en), [Haoyu Dong](https://haoyudong-97.github.io/), [Yaqian Chen](https://scholar.google.com/citations?user=iegKFuQAAAAJ&hl=en), [Andrew Marshall](https://linkedin.com/in/andrewmarshall26), [Lidia Garrucho](https://github.com/LidiaGarrucho), [Kaisar Kushibar](https://scholar.google.es/citations?user=VeHqMi4AAAAJ&hl=en), [Daniel M. Lang](https://scholar.google.com/citations?user=AV04Hs4AAAAJ&hl=en), [Gene S. Kim](https://vivo.weill.cornell.edu/display/cwid-sgk4001), [Lars J. Grimm](https://scholars.duke.edu/person/lars.grimm), [John M. Lewin](https://medicine.yale.edu/profile/john-lewin/), [James S. Duncan](https://medicine.yale.edu/profile/james-duncan/), [Julia A. Schnabel](https://compai-lab.github.io/), [Oliver Diaz](https://sites.google.com/site/odiazmontesdeoca/home), [Karim Lekadir](https://www.bcn-aim.org/) and [Maciej A. Mazurowski](https://sites.duke.edu/mazurowski/).
[](https://pypi.org/project/frd-score/)
[](https://anaconda.org/conda-forge/frd-score)
[](https://www.python.org/downloads/)
[](LICENSE)
[](https://github.com/RichardObi/frd-score/actions/workflows/ci.yml)
[](https://arxiv.org/abs/2412.01496)
[](https://richardobi.github.io/frd/)
# Fréchet Radiomics Distance (FRD)
**[Project Website](https://richardobi.github.io/frd/)** · **[Paper (Medical Image Analysis)](https://www.sciencedirect.com/science/article/pii/S1361841526000125)** · **[arXiv](https://arxiv.org/abs/2412.01496)** · **[Evaluation Framework](https://github.com/mazurowski-lab/medical-image-similarity-metrics)** · **[Documentation](https://richardobi.github.io/frd-score/)** · **[API](https://richardobi.github.io/frd-score/api/)**
<p align="center">
<img src="https://raw.githubusercontent.com/RichardObi/frd-score/main/docs/assets/teaser.png" alt="FRD overview" width="75%">
</p>
**FRD** measures the similarity of [radiomic](https://pyradiomics.readthedocs.io/) image features between two datasets by computing the [Fréchet distance](https://en.wikipedia.org/wiki/Fr%C3%A9chet_distance) between Gaussians fitted to the extracted and normalized features. The lower the FRD, the more similar the two datasets.
FRD supports both **2D** (PNG, JPG, TIFF, BMP) and **3D** (NIfTI `.nii.gz`) radiological images.
<p align="center">
<img src="https://raw.githubusercontent.com/RichardObi/frd-score/main/docs/assets/radiomics_taxonomy.jpg" alt="Radiomics feature taxonomy" width="75%">
</p>
## Why FRD over FID, KID, CMMD, etc.?
FRD uses *standardised radiomic features* rather than pretrained deep features (as in FID, KID, CMMD). We show in our paper that this yields:
1. **Better alignment** with downstream task performance (e.g. segmentation).
2. **Improved stability** and computational efficiency for small-to-moderately-sized datasets.
3. **Improved interpretability**, because radiomic features are clearly defined and widely used in medical imaging.
## FRD Versions
| | FRDv0 (Osuala et al., 2024) | FRDv1 (Konz, Osuala et al., 2026) — **default** |
|---|---|---|
| Features | ~94 (Original only) | ~464 (Original + LoG + Wavelet) |
| Normalization | min-max, joint | z-score, D1-referenced |
| Output | raw Fréchet distance | log-transformed Fréchet distance |
| Feature classes | firstorder, glcm, glrlm, gldm, glszm, ngtdm, shape, shape2D | firstorder, glcm, glrlm, glszm, ngtdm |
## Installation
### From PyPI (recommended)
```bash
pip install frd-score
```
> **Note:** `frd-score` requires [pyradiomics](https://github.com/AIM-Harvard/pyradiomics), which must be installed separately from GitHub because the PyPI release is broken for Python ≥ 3.10 ([#903](https://github.com/AIM-Harvard/pyradiomics/issues/903)):
```bash
pip install git+https://github.com/AIM-Harvard/pyradiomics.git@master
```
### From Conda (conda-forge)
```bash
conda install -c conda-forge frd-score
```
The conda-forge package includes all dependencies (including pyradiomics), so no additional installation steps are needed.
### From source
```bash
git clone https://github.com/RichardObi/frd-score.git
cd frd-score
pip install git+https://github.com/AIM-Harvard/pyradiomics.git@master
pip install -e ".[dev]"
```
### Requirements
- Python ≥ 3.10
- pyradiomics (installed from GitHub, see above)
- numpy, scipy, Pillow, SimpleITK, opencv-contrib-python-headless
<details>
<summary><strong>Windows users</strong></summary>
Building pyradiomics from source requires a C compiler and CMake. Install
[Visual Studio Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
with the "Desktop development with C++" workload, then retry the pip install.
</details>
## Quick Start
### CLI
```bash
# Compute FRD between two image folders (default: v1)
python -m frd_score path/to/dataset_A path/to/dataset_B
# Use FRDv0 instead
python -m frd_score path/to/dataset_A path/to/dataset_B --frd_version v0
# With masks
python -m frd_score path/to/dataset_A path/to/dataset_B -m path/to/masks_A path/to/masks_B
# Save precomputed statistics to .npz
python -m frd_score --save_stats path/to/dataset path/to/output.npz
# Re-use .npz file
python -m frd_score path/to/output.npz path/to/dataset_B
```
### Python API
```python
from frd_score import compute_frd
# Basic usage
frd_value = compute_frd(["path/to/dataset_A", "path/to/dataset_B"])
# With masks and options
frd_value = compute_frd(
["path/to/dataset_A", "path/to/dataset_B"],
paths_masks=["path/to/masks_A", "path/to/masks_B"],
frd_version="v1",
verbose=True,
)
# From file lists
frd_value = compute_frd([
["img1.png", "img2.png", "img3.png"],
["img4.png", "img5.png", "img6.png"],
])
```
## CLI Reference
### Main command
```
python -m frd_score path1 path2 [OPTIONS]
```
| Flag | Description | Default |
|------|-------------|---------|
| `--frd_version` | `v0` or `v1` | `v1` |
| `-m`, `--paths_masks` | Two mask folder paths | None |
| `-f`, `--feature_groups` | Feature classes to extract (e.g. `firstorder glcm`) | version default |
| `-I`, `--image_types` | Image filter types (`Original`, `LoG`, `Wavelet`) | version default |
| `-r`, `--resize_size` | Resize images to N×N or W×H | None |
| `-R`, `--norm_range` | Normalization range `[min max]` | version default |
| `-T`, `--norm_type` | `minmax` or `zscore` | version default |
| `--norm_ref` | Normalization reference: `joint`, `d1`, `independent` | version default |
| `-v`, `--verbose` | Verbose logging | off |
| `-w`, `--num_workers` | CPU workers for multiprocessing | auto |
| `-s`, `--save_stats` | Save statistics to `.npz` | off |
| `-F`, `--save_features` | Save features to CSV | off |
| `--use_paper_log` | Use paper Eq. 3 log transform: `log(√d²)` | off |
| `--means_only` | Mean-only Fréchet distance (no covariance) | off |
| `--log_sigma` | LoG sigma values | `[2.0, 3.0, 4.0, 5.0]` |
| `--bin_width` | PyRadiomics bin width | `5` |
| `--normalize_scale` | PyRadiomics normalize scale | `100` |
| `--voxel_array_shift` | PyRadiomics voxel array shift | `300` |
| `--config_path` | Custom PyRadiomics YAML config | None |
| `--exclude_features` | Post-extraction exclusion: `textural`, `wavelet`, `firstorder`, `shape` | None |
| `--match_sample_count` | Subsample larger dataset to match smaller | off |
| `--interpret` | Run interpretability analysis | off |
| `--interpret_dir` | Output dir for interpretation plots | `outputs/interpretability_visualizations` |
### OOD subcommand
```bash
# Image-level OOD detection
python -m frd_score ood path/to/reference path/to/test
# Dataset-level nFRD
python -m frd_score ood path/to/reference path/to/test --detection_type dataset
```
| Flag | Description | Default |
|------|-------------|---------|
| `--detection_type` | `image` or `dataset` | `image` |
| `--val_frac` | Fraction of reference held out for threshold | `0.1` |
| `--use_val_set` | Enable hold-out validation split | off |
| `--id_dist_assumption` | `gaussian`, `t`, or `counting` | `gaussian` |
| `--output_dir` | Directory for OOD CSV output | `outputs/ood_predictions` |
| `--seed` | Random seed for reproducibility | None |
All shared extraction flags (`--frd_version`, `-f`, `-I`, `--norm_ref`, etc.) are also available in the `ood` subcommand.
## Python API Reference
### `compute_frd(paths, **kwargs)`
Main entry point. See [API docs](https://richardobi.github.io/frd-score/api/) for the full signature and parameter descriptions.
### `save_frd_stats(paths, **kwargs)`
Compute and save feature statistics to a `.npz` file for later re-use. Accepts the same parameters as `compute_frd()`.
### `interpret_frd(feature_list, feature_names, **kwargs)`
Run interpretability analysis on extracted features. Produces t-SNE plots and per-feature difference rankings. Requires `matplotlib` and `scikit-learn`.
### `detect_ood(feature_list, **kwargs)`
Out-of-distribution detection using normalized radiomics features. Supports per-image scoring (`detection_type="image"`) and dataset-level nFRD (`detection_type="dataset"`).
## Interpretability
<p align="center">
<img src="https://raw.githubusercontent.com/RichardObi/frd-score/main/docs/assets/radiomic_interp.png" alt="Radiomic interpretability" width="65%">
</p>
FRD enables interpretable comparison of image sets. Use the `--interpret` flag or call `interpret_frd()` to:
- Rank the most-changed radiomic features between two distributions
- Visualise feature distributions via t-SNE
- Identify which images changed the most (for paired datasets)
```bash
python -m frd_score path/to/dataset_A path/to/dataset_B --interpret
```
## Out-of-Domain (OOD) Detection
FRD can detect whether newly acquired medical images come from the same domain as a reference set — useful for flagging potential distribution shifts (e.g. different scanners, protocols).
```bash
# Per-image OOD scores and p-values
python -m frd_score ood path/to/reference path/to/test_images
# Dataset-level OOD score (nFRD)
python -m frd_score ood path/to/reference path/to/test_images --detection_type dataset
```
Results are saved to `outputs/ood_predictions/ood_predictions.csv` with columns: `filename`, `ood_score`, `ood_prediction`, `p_value`.
## Citation
If you use this library in your research, please cite:
```bibtex
@article{konz2026frd,
title = {Fr\'{e}chet Radiomic Distance (FRD): A Versatile Metric for
Comparing Medical Imaging Datasets},
author = {Konz, Nicholas and Osuala, Richard and Verma, Preeti and
Chen, Yuwen and Gu, Hanxue and Dong, Haoyu and Chen, Yaqian
and Marshall, Andrew and Garrucho, Lidia and Kushibar, Kaisar
and Lang, Daniel M. and Kim, Gene S. and Grimm, Lars J. and
Lewin, John M. and Duncan, James S. and Schnabel, Julia A. and
Diaz, Oliver and Lekadir, Karim and Mazurowski, Maciej A.},
journal = {Medical Image Analysis},
volume = {110},
pages = {103943},
year = {2026},
publisher = {Elsevier},
doi = {10.1016/j.media.2026.103943},
url = {https://www.sciencedirect.com/science/article/pii/S1361841526000125},
}
```
Earlier FRD work:
```bibtex
@article{osuala2024towards,
title = {Towards Learning Contrast Kinetics with Multi-Condition
Latent Diffusion Models},
author = {Osuala, Richard and Lang, Daniel and Verma, Preeti and
Joshi, Smriti and Tsirikoglou, Apostolia and Skorupko, Grzegorz
and Kushibar, Kaisar and Garrucho, Lidia and Pinaya, Walter HL
and Diaz, Oliver and others},
journal = {arXiv preprint arXiv:2403.13890},
year = {2024},
}
```
## Links
- [API Documentation](https://richardobi.github.io/frd-score/api) — overview, benchmarks, datasets, FAQ
- [Change Log](https://richardobi.github.io/frd-score/changelog) — overview, benchmarks, datasets, FAQ
- [Project Website](https://richardobi.github.io/frd/) — overview, benchmarks, datasets, FAQ
- [Journal Article](https://www.sciencedirect.com/science/article/pii/S1361841526000125) — Medical Image Analysis, Vol. 110 (2026)
- [arXiv Preprint](https://arxiv.org/abs/2412.01496)
- [Evaluation Framework](https://github.com/mazurowski-lab/medical-image-similarity-metrics) — scripts for OOD detection, translation evaluation, and metric comparison
- [API Documentation](https://richardobi.github.io/frd-score/) — full docs hosted on GitHub Pages
## Acknowledgements
- [Preeti Verma](https://github.com/preeti-verma8600) — implementation of a script of an early frd version.
- [Nicholas Konz](https://nickk124.github.io/) — FRDv1 and [RaD](https://github.com/mazurowski-lab/RaD) repository
- [PyRadiomics](https://github.com/AIM-Harvard/pyradiomics) — radiomic feature extraction backend
- [pytorch-fid](https://github.com/mseitzer/pytorch-fid) — Fréchet distance implementation reference
## License
[Apache 2.0](LICENSE)
| text/markdown | Richard Osuala, Nick Konz, Preeti Verma | null | null | null | Apache-2.0 | Radiomics, Frechet, Distance, medical, imaging, radiology, generative, synthetic, evaluation | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"Intended Audience :: Healthcare Industry",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Scientific/Engineering :: Medical Science Apps.",
"Topic :: Scientific/Engineering :: Image Processing"
] | [] | https://github.com/RichardObi/frd-score | https://github.com/RichardObi/frd-score/archive/refs/tags/v1.0.0.tar.gz | >=3.10 | [] | [] | [] | [
"numpy",
"Pillow>=10.3.0",
"scipy>=1.10.0",
"opencv_contrib_python_headless>=4.8.1.78",
"SimpleITK>=2.3.1",
"flake8; extra == \"dev\"",
"flake8-bugbear; extra == \"dev\"",
"flake8-isort; extra == \"dev\"",
"black==24.3.0; extra == \"dev\"",
"isort; extra == \"dev\"",
"nox; extra == \"dev\"",
"pytest>=8.1.1; extra == \"dev\"",
"nibabel>=3.2.1; extra == \"dev\"",
"mkdocs-material>=9.0; extra == \"docs\"",
"mkdocstrings[python]>=0.25.0; extra == \"docs\"",
"mike>=2.0; extra == \"docs\""
] | [] | [] | [] | [
"Bug Tracker, https://github.com/RichardObi/frd-score/issues",
"Documentation, https://richardobi.github.io/frd-score/",
"Project Website, https://richardobi.github.io/frd/",
"Changelog, https://richardobi.github.io/frd-score/changelog/",
"Source, https://github.com/RichardObi/frd-score"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T03:59:29.384048 | frd_score-1.0.0.tar.gz | 42,388 | 1d/0c/f5e83096ceb959d04a455e174d3f7bd565622dc4d539b9bd1fa674da1965/frd_score-1.0.0.tar.gz | source | sdist | null | false | 103a97fbae1c782b4d0f861493a94730 | 155ef0008dd903e56bc10509c3be6838a5137bdf96663ac57d989997de9bfee1 | 1d0cf5e83096ceb959d04a455e174d3f7bd565622dc4d539b9bd1fa674da1965 | null | [
"LICENSE"
] | 227 |
2.3 | nonebot-plugin-message-snapper | 0.2.0 | 将引用的消息转换为图片发送 | <div align="center">
<a href="https://v2.nonebot.dev/store">
<img src="https://raw.githubusercontent.com/fllesser/nonebot-plugin-template/refs/heads/resource/.docs/NoneBotPlugin.svg" width="310" alt="logo"></a>
## ✨ nonebot-plugin-message-snapper ✨
[](./LICENSE)
[](https://pypi.python.org/pypi/nonebot-plugin-message-snapper)
[](https://www.python.org)
[](https://github.com/astral-sh/uv)
<br/>
[](https://github.com/astral-sh/ruff)
[](https://results.pre-commit.ci/latest/github/Xwei1645/nonebot-plugin-message-snapper/master)
</div>
## 📖 介绍
Message Snapper 是一个可用于自动生成 QQ 群聊中单条消息伪截图的 NoneBot 插件。
## 💿 安装
<details open>
<summary>使用 nb-cli 安装</summary>
在 nonebot2 项目的根目录下打开命令行, 输入以下指令即可安装
nb plugin install nonebot-plugin-message-snapper --upgrade
使用 **pypi** 源安装
nb plugin install nonebot-plugin-message-snapper --upgrade -i "https://pypi.org/simple"
使用**清华源**安装
nb plugin install nonebot-plugin-message-snapper --upgrade -i "https://pypi.tuna.tsinghua.edu.cn/simple"
</details>
<details>
<summary>使用包管理器安装</summary>
在 nonebot2 项目的插件目录下, 打开命令行, 根据你使用的包管理器, 输入相应的安装命令
<details open>
<summary>uv</summary>
uv add nonebot-plugin-message-snapper
安装仓库 master 分支
uv add git+https://github.com/Xwei1645/nonebot-plugin-message-snapper@master
</details>
<details>
<summary>pdm</summary>
pdm add nonebot-plugin-message-snapper
安装仓库 master 分支
pdm add git+https://github.com/Xwei1645/nonebot-plugin-message-snapper@master
</details>
<details>
<summary>poetry</summary>
poetry add nonebot-plugin-message-snapper
安装仓库 master 分支
poetry add git+https://github.com/Xwei1645/nonebot-plugin-message-snapper@master
</details>
打开 nonebot2 项目根目录下的 `pyproject.toml` 文件, 在 `[tool.nonebot]` 部分追加写入
plugins = ["nonebot_plugin_message_snapper"]
</details>
<details>
<summary>使用 nbr 安装(使用 uv 管理依赖可用)</summary>
[nbr](https://github.com/fllesser/nbr) 是一个基于 uv 的 nb-cli，可以方便地管理 nonebot2
nbr plugin install nonebot-plugin-message-snapper
使用 **pypi** 源安装
nbr plugin install nonebot-plugin-message-snapper -i "https://pypi.org/simple"
使用**清华源**安装
nbr plugin install nonebot-plugin-message-snapper -i "https://pypi.tuna.tsinghua.edu.cn/simple"
</details>
## ⚙️ 配置
在 nonebot2 项目的`.env`文件中添加下表中的必填配置
| 配置项 | 必填 | 默认值 | 说明 |
| :-----: | :---: | :----: | :------: |
| `message_snapper_template` | 否 | - | 自定义模板文件 |
| `message_snapper_font_family` | 否 | - | 用于渲染图片的字体家族 |
| `message_snapper_group_info_cache_hours` | 否 | `72.0` | 群信息缓存时长（小时） |
| `message_snapper_member_info_cache_hours` | 否 | `72.0` | 群成员信息缓存时长（小时） |
## 🎉 使用
### 指令表
| 指令 | 权限 | 需要@ | 范围 | 说明 |
| :---: | :---: | :---: | :---: | :------: |
| 'snap' 并引用一条消息 | 群成员 | 否 | 群聊 | 生成被引用消息的伪截图 |
### 🎨 效果图
没有效果图
| text/markdown | Xwei1645 | Xwei1645 <xwei1645@outlook.com> | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"nonebot-adapter-onebot<3.0.0,>=2.4.6",
"nonebot-plugin-message-snapper-core>=0.1.0",
"nonebot2<3.0.0,>=2.4.3"
] | [] | [] | [] | [
"Homepage, https://github.com/Xwei1645/nonebot-plugin-message-snapper",
"Issues, https://github.com/Xwei1645/nonebot-plugin-message-snapper/issues",
"Repository, https://github.com/Xwei1645/nonebot-plugin-message-snapper.git"
] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-21T03:58:16.175271 | nonebot_plugin_message_snapper-0.2.0-py3-none-any.whl | 4,351 | 78/05/10b46c17e949c1d1a5089d31c62e878ed0d6bd8996483b5a7b67fcf1abc2/nonebot_plugin_message_snapper-0.2.0-py3-none-any.whl | py3 | bdist_wheel | null | false | e6ba0e177ef8d41857fce9a51b947e22 | e4dfc3a241b3cb4ed4d55f9042d81eaa878eeaccebed3be9315be920301220ad | 780510b46c17e949c1d1a5089d31c62e878ed0d6bd8996483b5a7b67fcf1abc2 | null | [] | 212 |
2.4 | fluxibly | 1.0.1 | Modular Agentic Framework — LLM + Agent + Tools with MCP support | # Fluxibly
**Modular Agentic Framework — LLM + Agent + Tools**
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
Fluxibly is a framework for building **any** Agent pipeline simply. Provide general, easy-to-plug, mix-and-match components — to build a new Agent, you only tweak a few core pieces.
## Architecture
```
┌─────────────────────────────────────────────────────────────────────┐
│ USER / APPLICATION │
│ │
│ from fluxibly import Runner │
│ result = await Runner.run("config/agent.yaml", messages, context) │
│ │
└──────────────────────────────┬──────────────────────────────────────┘
│
┌──────────────────────────────▼──────────────────────────────────────┐
│ RUNNER (Execution Loop) │
│ Manages: handoff chain, max_turns, agent swapping, session sandbox │
│ run() → agent.forward() → if handoff → swap agent → repeat │
├─────────────────────────────────────────────────────────────────────┤
│ AGENT LAYER │
│ │
│ BaseAgent (abstract) → SimpleAgent, CustomAgent, ... │
│ Manages: LLMs, tools, prompts, delegation (handoffs + agents) │
│ forward() = prepare → LLM → tool loop → return │
│ │
│ Delegation: │
│ Handoffs ────── transfer_to_xxx → one-way control transfer │
│ Agents-as-tools agent_xxx → delegate & return │
│ Skills ────── load_skill → on-demand instruction loading │
├─────────────────────────────────────────────────────────────────────┤
│ LLM LAYER │
│ │
│ BaseLLM (abstract) → OpenAILLM, AnthropicLLM, GeminiLLM │
│ → LangChainLLM, LiteLLM │
│ prepare() → format for provider │
│ forward() → single inference, standardized output │
├─────────────────────────────────────────────────────────────────────┤
│ TOOLS LAYER │
│ │
│ Functions │ MCP │ Web Search │ File Search │ Shell │ Computer Use │
└─────────────────────────────────────────────────────────────────────┘
```
## Installation
```bash
pip install fluxibly
```
With provider extras:
```bash
pip install fluxibly[openai] # OpenAI only
pip install fluxibly[anthropic] # Anthropic only
pip install fluxibly[gemini] # Google Gemini only
pip install fluxibly[all] # All providers
```
## Usage
### Run an Agent
The simplest way — pass a config path to `Runner.run()`. It loads the config, resolves the agent class, and runs.
```python
import asyncio
from fluxibly import Runner
async def main():
result = await Runner.run(
"agents/my_agent.yaml",
[{"role": "user", "content": "Hello!"}],
)
print(result.response.content.output.output_text)
asyncio.run(main())
```
`Runner.run()` accepts:
| Input | What happens |
| --- | --- |
| `str` (path/name) | Loads config YAML → resolves `agent_class` → instantiates → runs |
| `AgentConfig` | Resolves `agent_class` → instantiates → runs |
| `BaseAgent` instance | Uses directly → runs |
### Agent Config (YAML)
Every agent is a YAML file:
```yaml
# agents/my_agent.yaml
name: "my_agent"
description: "A helpful general assistant"
# agent_class: "SimpleAgent" # Default — or "path.to.module::CustomAgent"
llm:
model: "gpt-4o"
temperature: 0.7
system_prompt: "You are a helpful assistant."
tools:
- "lookup_faq" # Tool name → resolved from tools/ directory
- "./tools/web_search.yaml" # Tool path → loaded directly
handoffs:
- "billing_specialist" # Agent name → one-way transfer
- agent: "refund_specialist" # With custom options
input_filter: "remove_tools"
agents:
- "researcher" # Agent name → delegate & return
skills:
- "csv-insights" # Skill name → on-demand loading
sandbox: # Optional: sandboxed shell execution config
use_uv: true # Create a uv venv in the sandbox
packages: ["pandas"] # Pre-install packages in the venv
timeout_seconds: 300 # Command timeout (default: 300)
max_tool_iterations: 10
```
### Create a New Tool
Each tool has two files — a **YAML schema** and an optional **Python handler**:
```text
tools/get_weather/
├── get_weather.yaml # Required: schema (what the LLM sees)
├── get_weather.py # Optional: handler (what runs when called)
└── requirements.txt # Optional: Python dependencies (auto-installed)
```
```yaml
# tools/get_weather/get_weather.yaml — schema
type: "function"
function:
name: "get_weather"
description: "Get current weather for a city"
parameters:
type: "object"
properties:
city: { type: "string", description: "City name" }
required: ["city"]
```
```python
# tools/get_weather/get_weather.py — handler
async def handler(city: str) -> str:
return f"Weather for {city}: sunny, 72°F"
```
If a `requirements.txt` sits alongside the tool YAML, dependencies are auto-installed into the sandbox venv on first use. The file follows the standard [uv/pip requirements format](https://docs.astral.sh/uv/pip/packages/#installing-from-a-requirements-file):
```text
# tools/get_weather/requirements.txt
requests>=2.31
```
The handler `.py` file is auto-discovered by name (same stem as the `.yaml`). If a tool needs runtime context (e.g., a sandbox session), use the factory pattern:
```python
# tools/file_stats.py — factory handler (receives sandbox session)
async def create_handler(*, session=None, **kwargs):
async def file_stats(file_path: str) -> str:
r = await session.run(f"wc {file_path}")
return r.stdout or r.stderr
return file_stats
```
Reference tools from an agent config:
```yaml
# agents/weather_agent.yaml
name: "weather_agent"
llm:
model: "gpt-4o-mini"
system_prompt: "You help with weather queries."
tools:
- "get_weather"
```
The agent auto-discovers the YAML schema, the `.py` handler, and `requirements.txt` — no manual wiring needed.
### Create a New Agent (for delegation)
Each agent is its own YAML config. Reference it as a handoff or agent-as-tool from another agent:
```yaml
# agents/researcher.yaml
name: "researcher"
description: "Do deep web research on a topic. Returns a summary."
llm:
model: "gpt-4o-mini"
temperature: 0.3
system_prompt: "You are a research assistant."
tools:
- "web_search"
```
```yaml
# agents/manager.yaml
name: "manager"
description: "Senior analyst who delegates research and writing"
llm:
model: "gpt-4o"
system_prompt: "Break down questions. Use your research and writing agents."
# These become agent_researcher and agent_writer tools
agents:
- "researcher"
- "writer"
```
```python
result = await Runner.run("agents/manager.yaml", messages)
```
### Create a New Skill
Skills are on-demand instructions that load only when needed. Each skill is a directory with a `SKILL.md`:
```text
skills/csv-insights/
├── SKILL.md # Required: metadata + instructions
├── requirements.txt # Optional: Python dependencies (auto-installed)
├── scripts/ # Optional: executable code
│ └── analyze.py
└── assets/ # Optional: reference files
```
```markdown
---
name: csv-insights
description: Summarize a CSV, compute basic stats, and produce a markdown report.
---
# CSV Insights Skill
## When to use this
- User provides a CSV and wants a summary, stats, or visualization
## How to run
python scripts/analyze.py --input <csv_path> --outdir output
```
Only the frontmatter (`name` + `description`) is loaded at startup. The full body loads when the LLM calls `load_skill`.
**Skill staging:** When a sandbox is configured, the skill directory (including `scripts/`) is automatically copied into the sandbox so the LLM can reference and execute scripts via shell commands.
**Auto-install:** If the skill directory contains a `requirements.txt`, dependencies are automatically installed into the sandbox venv before the first LLM call. The file uses standard [uv/pip requirements format](https://docs.astral.sh/uv/pip/packages/#installing-from-a-requirements-file).
Reference from an agent config:
```yaml
skills:
- "csv-insights"
```
### Runtime Context
Pass additional resources at runtime via `context`:
```python
result = await Runner.run(
"agents/my_agent.yaml",
messages,
context={
"prompt_params": {
"domain": "finance",
"system": {"personality": "formal"},
},
"tools": ["extra_tool"],
"agents": ["extra_agent"],
"skills": ["extra_skill"],
},
)
```
### Dynamic Resource Bundles
Inject full resource definitions at runtime (e.g. from an external service):
```python
agent_bundle = {
"name": "specialist_v2",
"type": "agent",
"resources": {
"config.yaml": 'name: "specialist_v2"\nllm:\n model: "gpt-4o"\n...',
"agent.py": 'class SpecialistV2(SimpleAgent):\n ...',
},
"structure": {"config.yaml": "file", "agent.py": "file"},
}
result = await Runner.run(
"agents/triage.yaml",
messages,
context={"agents": [agent_bundle]},
)
```
Bundles are materialized to the session sandbox as real files, then resolved identically to any other path.
## Sandboxed Execution
When tools or skills need to run shell commands, Fluxibly provides OS-level isolation using [Anthropic's sandbox-runtime (SRT)](https://github.com/anthropic-experimental/sandbox-runtime) and fast Python environment creation via [uv](https://docs.astral.sh/uv/).
Sandboxing is **lazy** — nothing is created until the first shell command runs. The sandbox is then reused for the entire session and cleaned up automatically by the Runner.
Install SRT for OS-level isolation (optional):
```bash
npm install -g @anthropic-ai/sandbox-runtime
brew install ripgrep # Required by SRT (macOS)
```
If SRT is not installed, commands fall back to direct subprocess execution with a warning.
### Sandbox YAML config
```yaml
sandbox:
use_uv: true # Create a uv venv in the sandbox (default: true)
python_version: "3.11" # Python version for uv venv (default: system)
packages: ["pandas", "matplotlib"] # Pre-install packages on first use (prefer requirements.txt)
timeout_seconds: 300 # Max seconds per command (default: 300)
allowed_domains: # Network allowlist (default: pypi.org, github.com)
- "pypi.org"
- "files.pythonhosted.org"
deny_read: # Filesystem read denylist (default: ~/.ssh, ~/.aws, .env)
- "~/.ssh"
- "~/.aws"
allow_write: ["/data/output"] # Extra writable paths beyond sandbox_dir
```
> **Prefer `requirements.txt`**: Instead of listing packages in the sandbox config, place a `requirements.txt` in each tool or skill directory. Dependencies are auto-installed on first use, and each tool/skill owns its own deps.
### Programmatic usage
```python
from fluxibly import SandboxSession
from fluxibly.tools import ToolService
session = SandboxSession("/tmp/my-sandbox")
ts = ToolService()
ts.register_sandboxed_shell(session) # Registers a "shell" function tool
```
See `fluxibly/tools/sandbox.py` and `examples/03_multi_agent.py` for details.
## Environment Setup
Copy `.env.example` to `.env` and fill in your values:
```bash
cp .env.example .env
```
The `.env` file is auto-loaded when you import `fluxibly`. At minimum, set your LLM provider API key:
```bash
# .env
OPENAI_API_KEY=sk-...
# or
ANTHROPIC_API_KEY=sk-ant-...
# or
GOOGLE_API_KEY=...
```
See `.env.example` for the full list of available settings (database, monitoring, etc.).
## Monitoring
Fluxibly includes built-in monitoring that records traces, spans, and tool calls to a PostgreSQL database. Monitoring is configured **exclusively via environment variables** in your `.env` file — never through agent YAML configs.
### 1. Set up the database
Create a PostgreSQL database for monitoring data:
```bash
createdb fluxibly_monitoring
```
### 2. Enable monitoring in `.env`
```bash
FLUXIBLY_MONITORING_ENABLED=true
FLUXIBLY_MONITORING_DASHBOARD_DB_HOST=localhost
FLUXIBLY_MONITORING_DASHBOARD_DB_PORT=5432
FLUXIBLY_MONITORING_DASHBOARD_DB_NAME=fluxibly_monitoring
FLUXIBLY_MONITORING_DASHBOARD_DB_USER=postgres
FLUXIBLY_MONITORING_DASHBOARD_DB_PASSWORD=your_password
```
When `FLUXIBLY_MONITORING_ENABLED=true`, all agents automatically pick up monitoring — no code changes needed. Tables are created automatically on first run.
### 3. Launch the monitoring dashboard
```bash
python -m fluxibly.monitoring.dashboard
```
The dashboard runs at `http://localhost:8555` by default. You can customize the host/port:
```bash
python -m fluxibly.monitoring.dashboard --host 0.0.0.0 --port 9000
```
Or via environment variables:
```bash
FLUXIBLY_MONITORING_DASHBOARD_HOST=0.0.0.0
FLUXIBLY_MONITORING_DASHBOARD_PORT=8555
```
## Custom Agents
Extend `AgentTemplate` to build custom agents with pre/post hooks:
```python
from fluxibly.agent import AgentTemplate, AgentConfig, AgentResponse
class MyAgent(AgentTemplate):
async def pre_forward(self, messages, context):
# Inject custom params before the pipeline runs
context.setdefault("prompt_params", {})
context["prompt_params"]["custom_var"] = "value"
return messages, context
async def post_forward(self, response, messages, context):
# Inspect or modify the response
return response
```
See `examples/04_custom_agent.py` for a full working example.
## Requirements
- Python 3.11+
- API keys for your chosen LLM provider
- **For sandboxed execution (optional):**
- [SRT](https://github.com/anthropic-experimental/sandbox-runtime): `npm install -g @anthropic-ai/sandbox-runtime`
- [ripgrep](https://github.com/BurningMind/ripgrep): `brew install ripgrep` (macOS) / `apt install ripgrep` (Linux) — required by SRT
- [uv](https://docs.astral.sh/uv/): `pip install uv` or `brew install uv` — for fast venv creation
## License
MIT License — see [LICENSE](LICENSE) for details.
| text/markdown | null | Lavaflux <contact@lavaflux.com> | null | null | MIT | agent, ai, anthropic, automation, gemini, llm, mcp, openai | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"anyio>=4.0.0",
"loguru>=0.7.3",
"mcp>=1.0.0",
"pydantic>=2.0.0",
"python-dotenv>=1.0.0",
"pyyaml>=6.0",
"anthropic>=0.30.0; extra == \"all\"",
"asyncpg>=0.29.0; extra == \"all\"",
"fastapi>=0.110.0; extra == \"all\"",
"google-generativeai>=0.7.0; extra == \"all\"",
"jinja2>=3.1.0; extra == \"all\"",
"langchain-anthropic>=1.2.0; extra == \"all\"",
"langchain-core>=0.3.0; extra == \"all\"",
"langchain-google-genai>=4.0.0; extra == \"all\"",
"langchain-openai>=0.2.0; extra == \"all\"",
"langchain>=0.3.0; extra == \"all\"",
"litellm>=1.80.9; extra == \"all\"",
"openai>=1.30.0; extra == \"all\"",
"python-multipart>=0.0.6; extra == \"all\"",
"uvicorn[standard]>=0.27.0; extra == \"all\"",
"anthropic>=0.30.0; extra == \"anthropic\"",
"build>=1.4.0; extra == \"dev\"",
"pyright>=1.1.0; extra == \"dev\"",
"pytest-asyncio>=0.23.0; extra == \"dev\"",
"pytest-cov>=4.1.0; extra == \"dev\"",
"pytest-mock>=3.12.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\"",
"ruff>=0.8.0; extra == \"dev\"",
"twine>=6.2.0; extra == \"dev\"",
"google-generativeai>=0.7.0; extra == \"gemini\"",
"langchain-anthropic>=1.2.0; extra == \"langchain\"",
"langchain-core>=0.3.0; extra == \"langchain\"",
"langchain-google-genai>=4.0.0; extra == \"langchain\"",
"langchain-openai>=0.2.0; extra == \"langchain\"",
"langchain>=0.3.0; extra == \"langchain\"",
"litellm>=1.80.9; extra == \"litellm\"",
"opencv-python>=4.9.0; extra == \"mcp-servers\"",
"openpyxl>=3.1.0; extra == \"mcp-servers\"",
"pandas>=2.2.0; extra == \"mcp-servers\"",
"pdf2image>=1.17.0; extra == \"mcp-servers\"",
"pillow>=10.0.0; extra == \"mcp-servers\"",
"pytesseract>=0.3.10; extra == \"mcp-servers\"",
"qdrant-client>=1.16.2; extra == \"mcp-servers\"",
"rich>=13.0.0; extra == \"mcp-servers\"",
"sentence-transformers>=5.2.0; extra == \"mcp-servers\"",
"asyncpg>=0.29.0; extra == \"monitoring\"",
"fastapi>=0.110.0; extra == \"monitoring\"",
"jinja2>=3.1.0; extra == \"monitoring\"",
"python-multipart>=0.0.6; extra == \"monitoring\"",
"uvicorn[standard]>=0.27.0; extra == \"monitoring\"",
"openai>=1.30.0; extra == \"openai\""
] | [] | [] | [] | [
"Homepage, https://github.com/Lavaflux/fluxibly",
"Documentation, https://github.com/Lavaflux/fluxibly#readme",
"Repository, https://github.com/Lavaflux/fluxibly",
"Issues, https://github.com/Lavaflux/fluxibly/issues"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-21T03:56:35.890010 | fluxibly-1.0.1.tar.gz | 363,327 | e5/ae/ce77ee994befce8791d71f41940875f51497ff711f84cf89e2d48ae7824a/fluxibly-1.0.1.tar.gz | source | sdist | null | false | 29a18d2743d1cdd0041d475c05e1cd63 | 286c829639a2c8b572118de47ce6f66a4745d125a6795985d8caf2d99f8e4fc6 | e5aece77ee994befce8791d71f41940875f51497ff711f84cf89e2d48ae7824a | null | [] | 233 |
2.4 | types-fpdf2 | 2.8.4.20260221 | Typing stubs for fpdf2 | ## Typing stubs for fpdf2
This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html)
for the [`fpdf2`](https://github.com/py-pdf/fpdf2) package. It can be used by type checkers
to check code that uses `fpdf2`. This version of
`types-fpdf2` aims to provide accurate annotations for
`fpdf2==2.8.4`.
*Note:* The `fpdf2` package includes type annotations or type stubs
since version 2.8.6. Please uninstall the `types-fpdf2`
package if you use this or a newer version.
This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/fpdf2`](https://github.com/python/typeshed/tree/main/stubs/fpdf2)
directory.
This package was tested with the following type checkers:
* [mypy](https://github.com/python/mypy/) 1.19.1
* [pyright](https://github.com/microsoft/pyright) 1.1.408
It was generated from typeshed commit
[`9e6b58fad088ca14346e6f7ffd80b9d84b83aed1`](https://github.com/python/typeshed/commit/9e6b58fad088ca14346e6f7ffd80b9d84b83aed1).
| text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Typing :: Stubs Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"Pillow>=10.3.0"
] | [] | [] | [] | [
"Homepage, https://github.com/python/typeshed",
"GitHub, https://github.com/python/typeshed",
"Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/fpdf2.md",
"Issue tracker, https://github.com/python/typeshed/issues",
"Chat, https://gitter.im/python/typing"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-21T03:55:29.005255 | types_fpdf2-2.8.4.20260221.tar.gz | 41,609 | 09/12/8397bbcd0ba4ee5c21c1905363fe0752f72b627096f000dd04ed7b484f21/types_fpdf2-2.8.4.20260221.tar.gz | source | sdist | null | false | ab76d92dd005fe18823c527527aefa55 | 4350911f72fad000e351eb8b0ad8d7c7f8f8476b273100f33eeb41fbab737028 | 09128397bbcd0ba4ee5c21c1905363fe0752f72b627096f000dd04ed7b484f21 | Apache-2.0 | [
"LICENSE"
] | 1,188 |
2.4 | types-regex | 2026.2.19.20260221 | Typing stubs for regex | ## Typing stubs for regex
This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html)
for the [`regex`](https://github.com/mrabarnett/mrab-regex) package. It can be used by type checkers
to check code that uses `regex`. This version of
`types-regex` aims to provide accurate annotations for
`regex==2026.2.19`.
This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/regex`](https://github.com/python/typeshed/tree/main/stubs/regex)
directory.
This package was tested with the following type checkers:
* [mypy](https://github.com/python/mypy/) 1.19.1
* [pyright](https://github.com/microsoft/pyright) 1.1.408
It was generated from typeshed commit
[`9e6b58fad088ca14346e6f7ffd80b9d84b83aed1`](https://github.com/python/typeshed/commit/9e6b58fad088ca14346e6f7ffd80b9d84b83aed1).
| text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Typing :: Stubs Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/python/typeshed",
"GitHub, https://github.com/python/typeshed",
"Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/regex.md",
"Issue tracker, https://github.com/python/typeshed/issues",
"Chat, https://gitter.im/python/typing"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-21T03:55:24.882180 | types_regex-2026.2.19.20260221.tar.gz | 13,125 | d6/dd/66bbc1afdff89254a9f42beeeb435256f3d8b85ab36500583cf2d7b1ede2/types_regex-2026.2.19.20260221.tar.gz | source | sdist | null | false | 0dae499243a8d0b52ceb0a39bcf7c09a | bbe7d01d7fdcdceda7bbe2b3e1350be79e9d758f61f98aa7b0481ccc55ce67cb | d6dd66bbc1afdff89254a9f42beeeb435256f3d8b85ab36500583cf2d7b1ede2 | Apache-2.0 | [
"LICENSE"
] | 4,956 |
2.4 | types-assertpy | 1.1.0.20260221 | Typing stubs for assertpy | ## Typing stubs for assertpy
This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html)
for the [`assertpy`](https://github.com/assertpy/assertpy) package. It can be used by type checkers
to check code that uses `assertpy`. This version of
`types-assertpy` aims to provide accurate annotations for
`assertpy==1.1.*`.
This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/assertpy`](https://github.com/python/typeshed/tree/main/stubs/assertpy)
directory.
This package was tested with the following type checkers:
* [mypy](https://github.com/python/mypy/) 1.19.1
* [pyright](https://github.com/microsoft/pyright) 1.1.408
It was generated from typeshed commit
[`9e6b58fad088ca14346e6f7ffd80b9d84b83aed1`](https://github.com/python/typeshed/commit/9e6b58fad088ca14346e6f7ffd80b9d84b83aed1).
| text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Typing :: Stubs Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/python/typeshed",
"GitHub, https://github.com/python/typeshed",
"Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/assertpy.md",
"Issue tracker, https://github.com/python/typeshed/issues",
"Chat, https://gitter.im/python/typing"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-21T03:55:21.504773 | types_assertpy-1.1.0.20260221.tar.gz | 10,695 | 8a/0c/aa2956136c8895e08d165370fa4eea36380c2bd5cd29ef6081f0fc4b590d/types_assertpy-1.1.0.20260221.tar.gz | source | sdist | null | false | 3c69c59bf08f5c12259d004543f49a24 | 9245b78463fc7216c2fe9e5dc4e1b544440680af92485c21c6e80d6518f174a0 | 8a0caa2956136c8895e08d165370fa4eea36380c2bd5cd29ef6081f0fc4b590d | Apache-2.0 | [
"LICENSE"
] | 387 |
2.4 | types-reportlab | 4.4.10.20260221 | Typing stubs for reportlab | ## Typing stubs for reportlab
This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html)
for the [`reportlab`](https://github.com/MrBitBucket/reportlab-mirror) package. It can be used by type checkers
to check code that uses `reportlab`. This version of
`types-reportlab` aims to provide accurate annotations for
`reportlab==4.4.10`.
This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/reportlab`](https://github.com/python/typeshed/tree/main/stubs/reportlab)
directory.
This package was tested with the following type checkers:
* [mypy](https://github.com/python/mypy/) 1.19.1
* [pyright](https://github.com/microsoft/pyright) 1.1.408
It was generated from typeshed commit
[`9e6b58fad088ca14346e6f7ffd80b9d84b83aed1`](https://github.com/python/typeshed/commit/9e6b58fad088ca14346e6f7ffd80b9d84b83aed1).
| text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Typing :: Stubs Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/python/typeshed",
"GitHub, https://github.com/python/typeshed",
"Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/reportlab.md",
"Issue tracker, https://github.com/python/typeshed/issues",
"Chat, https://gitter.im/python/typing"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-21T03:55:17.833149 | types_reportlab-4.4.10.20260221.tar.gz | 71,239 | 6f/44/456e85d2d1d739bf906e899481ed2e0c2498dd3b863472f0129e8ccbcfba/types_reportlab-4.4.10.20260221.tar.gz | source | sdist | null | false | c52e6aa9c6caebe7bd66623cc463527c | aac9035c7bd200efe3bf63202e6f4b146f9cd41c10fa4b2823b283f20cae32c2 | 6f44456e85d2d1d739bf906e899481ed2e0c2498dd3b863472f0129e8ccbcfba | Apache-2.0 | [
"LICENSE"
] | 1,077 |
2.4 | types-protobuf | 6.32.1.20260221 | Typing stubs for protobuf | ## Typing stubs for protobuf
This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html)
for the [`protobuf`](https://github.com/protocolbuffers/protobuf) package. It can be used by type checkers
to check code that uses `protobuf`. This version of
`types-protobuf` aims to provide accurate annotations for
`protobuf~=6.32.1`.
Partially generated using [mypy-protobuf==3.6.0](https://github.com/nipunn1313/mypy-protobuf/tree/v3.6.0) and libprotoc 31.1 on [protobuf v32.1](https://github.com/protocolbuffers/protobuf/releases/tag/v32.1) (python `protobuf==6.32.1`).
This stub package is marked as [partial](https://typing.python.org/en/latest/spec/distributing.html#partial-stub-packages).
If you find that annotations are missing, feel free to contribute and help complete them.
This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/protobuf`](https://github.com/python/typeshed/tree/main/stubs/protobuf)
directory.
This package was tested with the following type checkers:
* [mypy](https://github.com/python/mypy/) 1.19.1
* [pyright](https://github.com/microsoft/pyright) 1.1.408
It was generated from typeshed commit
[`9e6b58fad088ca14346e6f7ffd80b9d84b83aed1`](https://github.com/python/typeshed/commit/9e6b58fad088ca14346e6f7ffd80b9d84b83aed1).
| text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Typing :: Stubs Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/python/typeshed",
"GitHub, https://github.com/python/typeshed",
"Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/protobuf.md",
"Issue tracker, https://github.com/python/typeshed/issues",
"Chat, https://gitter.im/python/typing"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-21T03:55:13.916939 | types_protobuf-6.32.1.20260221.tar.gz | 64,408 | 5f/e2/9aa4a3b2469508bd7b4e2ae11cbedaf419222a09a1b94daffcd5efca4023/types_protobuf-6.32.1.20260221.tar.gz | source | sdist | null | false | cb5cb3c8941eaf0aaf63ff71add4a994 | 6d5fb060a616bfb076cbb61b4b3c3969f5fc8bec5810f9a2f7e648ee5cbcbf6e | 5fe29aa4a3b2469508bd7b4e2ae11cbedaf419222a09a1b94daffcd5efca4023 | Apache-2.0 | [
"LICENSE"
] | 197,003 |
2.4 | basileus | 0.1.2 | CLI for deploying Basileus autonomous AI Agents | # Basileus CLI
Deploy and manage autonomous AI agents on Base — from zero to a running self-sustaining agent in one command.
## Install
```bash
pip install basileus
```
## Commands
### `basileus deploy`
Full end-to-end deployment of a new agent:
1. **Wallet setup** — generates a new Base wallet (or reuses existing from `.env.prod`)
2. **Funding** — prompts you to send ETH, then auto-swaps to ALEPH (compute) + USDC (inference)
3. **ENS subdomain** — registers `<name>.basileus-agent.eth` and sets `contentHash` for the dashboard
4. **ERC-8004 identity** — uploads metadata to IPFS and registers the agent on-chain
5. **Aleph Cloud VM** — creates a compute instance, sets up Superfluid payment streams (operator + community)
6. **Code deployment** — uploads agent code via SSH, installs Node.js + deps, configures systemd service
```bash
basileus deploy [PATH]
```
| Option | Default | Description |
| ----------- | ----------- | ----------------------------------------- |
| `PATH` | `.` | Path to agent directory |
| `--min-eth` | `0.02` | Minimum ETH to wait for before proceeding |
| `--ssh-key` | auto-detect | Path to SSH public key |
### `basileus register`
Register an already-deployed agent on the ERC-8004 IdentityRegistry. Useful if deployment was interrupted after the VM was created but before on-chain registration completed.
```bash
basileus register [PATH]
```
Requires an existing wallet (`.env.prod`) and ENS subname.
### `basileus set-content-hash`
Update the ENS `contentHash` for an agent's subname. Used when the frontend IPFS hash changes and dashboards need to point to the new version.
```bash
basileus set-content-hash [PATH]
```
### `basileus stop`
Tear down a running agent — deletes Aleph Cloud instance and closes Superfluid payment streams.
```bash
basileus stop [PATH]
```
Prompts for confirmation before proceeding. Shows what resources will be deleted.
## What Happens Under the Hood
```
basileus deploy
│
├─ Wallet
│ ├─ Generate keypair (or load from .env.prod)
│ └─ Write WALLET_PRIVATE_KEY + BUILDER_CODE to .env.prod
│
├─ Funding
│ ├─ Wait for ETH deposit to agent address
│ ├─ Swap ETH → ALEPH (~10 tokens for compute)
│ ├─ Swap ETH → USDC (for x402 inference payments)
│ └─ Reserve 0.001 ETH for gas
│
├─ ENS
│ ├─ Register <name>.basileus-agent.eth via L2Registrar
│ └─ Set contentHash (IPFS pointer to dashboard frontend)
│
├─ ERC-8004
│ ├─ Build agent metadata (name, description, services)
│ ├─ Upload metadata to IPFS via Aleph
│ └─ Register on IdentityRegistry (mint agent NFT)
│
├─ Aleph Cloud
│ ├─ Create compute instance on CRN
│ ├─ Compute Superfluid flow rates
│ ├─ Create operator payment stream (ALEPH)
│ ├─ Create community payment stream (ALEPH)
│ ├─ Notify CRN for allocation
│ └─ Wait for instance to come up
│
└─ Code Deployment
├─ Wait for SSH access
├─ Upload agent source code
├─ Install Node.js runtime
├─ Install npm dependencies
├─ Configure systemd service
└─ Verify service is running
```
## Dependencies
- [web3.py](https://github.com/ethereum/web3.py) — Ethereum interactions
- [aleph-sdk-python](https://github.com/aleph-im/aleph-sdk-python) — Aleph Cloud instance management + IPFS
- [paramiko](https://github.com/paramiko/paramiko) — SSH for VM deployment
- [typer](https://github.com/tiangolo/typer) + [rich](https://github.com/Textualize/rich) — CLI interface
## Development
```bash
cd cli
poetry install
poetry run basileus --help
```
| text/markdown | Basileus Team | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | <3.14,>=3.11 | [] | [] | [] | [
"aleph-sdk-python<3.0.0,>=2.3.0",
"eth-account<0.14.0,>=0.13.0",
"paramiko<4.0.0,>=3.5.1",
"pathspec<0.13.0,>=0.12.1",
"python-dotenv<2.0.0,>=1.0.1",
"typer[all]<0.16.0,>=0.15.0",
"web3<8.0.0,>=7.0.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T03:55:11.576473 | basileus-0.1.2.tar.gz | 20,079 | 7c/3f/7fe2017997290aefae5adf27f0c7c9d00136845fd3aab4d4860384f605a4/basileus-0.1.2.tar.gz | source | sdist | null | false | 50433abc513e6c289296a3e4f99fe00d | 2c1c51af2d728e07bc490694a594a9cf6a753a5e45a20650e46403ed9bb1a503 | 7c3f7fe2017997290aefae5adf27f0c7c9d00136845fd3aab4d4860384f605a4 | null | [] | 220 |
2.4 | socialseed-e2e | 0.1.5 | Framework E2E para testing de APIs REST con Playwright | # 🌱 SocialSeed E2E
[](https://pypi.org/project/socialseed-e2e/)
[](https://pypi.org/project/socialseed-e2e/)
[](https://daironpf.github.io/socialseed-e2e/)
[](LICENSE)
[](https://pypi.org/project/socialseed-e2e/)
## The Problem: Your E2E Tests Are Brittle and Slow
If you're a QA engineer or developer, you know the pain:
- **Fragile tests** that break with every minor UI or API change
- **Complex setup** requiring multiple tools and configurations
- **Slow feedback loops** waiting hours for test suites to run
- **Unreliable CI/CD** with flaky tests causing false positives
- **Repetitive boilerplate** writing the same test patterns over and over
## The Solution: Reliable E2E Testing That Scales
SocialSeed E2E is a testing platform designed for **production reliability** with optional AI acceleration.
### Who is this for?
- **QA Engineers** who need stable, maintainable API tests without writing boilerplate
- **Developers** who want fast feedback on API changes without the overhead
- **Teams** transitioning from experimental AI testing to a production-ready solution
### Why we built this?
Most AI-driven testing frameworks promise the world but deliver unreliable, flaky tests. We wanted something different:
1. **Reliability First** - Tests that pass when they should, fail when they must
2. **Optional AI Acceleration** - Use AI to generate tests faster when you want it, but never required
3. **Developer Experience** - CLI that gets out of your way and lets you focus on testing
4. **Production Ready** - Built for CI/CD pipelines from day one
> **"Write tests that survive your API changing, not tests that break on every update."**
📚 **[Full Documentation](https://daironpf.github.io/socialseed-e2e/)**
---
## 🚀 Quick Start
Get up and running in under 5 minutes with this minimal setup:
### 1. Install
```bash
pip install socialseed-e2e
```
### 2. Initialize Project
```bash
e2e init demo
cd demo
```
**Output:**
```
🌱 Initializing E2E project at: /path/to/demo
✓ Created: services
✓ Created: tests
✓ Created: .github/workflows
✓ Created: e2e.conf
✓ Created: .gitignore
✓ Created: requirements.txt
✓ Created: .agent/ (AI Documentation)
✅ Project initialized successfully!
```
### 3. Create Your First Service
```bash
e2e new-service demo-api --base-url http://localhost:8080
```
**Generated Folder Structure:**
```
demo/
├── e2e.conf # Configuration file
├── services/
│ └── demo-api/
│ ├── __init__.py
│ ├── demo_api_page.py # Service Page class
│ ├── data_schema.py # Data models
│ └── modules/ # Test modules
├── tests/ # Additional tests
└── .github/workflows/ # CI/CD templates
```
### 4. Create Your First Test
```bash
e2e new-test health --service demo-api
```
This creates `services/demo-api/modules/01_health_flow.py` with a test template.
### 5. Start Your API (3 Options)
Before running tests, you need an API server running. You have three options:
#### Option A: Use the Included Demo API (Recommended for beginners)
The `e2e init` command automatically creates a demo REST API with CRUD operations:
```bash
# Install dependencies (includes Flask for the demo API)
pip install -r requirements.txt
# Start the demo API (in a separate terminal)
cd demo
python api-rest-demo.py
# The API will start on http://localhost:5000
# It includes 10 sample users and full CRUD endpoints
```
**Note:** If you get a `ModuleNotFoundError: No module named 'flask'` error, install Flask manually:
```bash
pip install flask>=2.0.0
```
**Update your service to use the demo API:**
```bash
# Edit e2e.conf and change the base_url to http://localhost:5000
e2e set url demo-api http://localhost:5000
```
#### Option B: Use Your Own API
Ensure your API is running at the configured base URL (e.g., `http://localhost:8080`):
```bash
# Start your API (example)
python your_api.py
# or
npm start
# or
docker-compose up
```
#### Option C: Use the Built-in Mock Server
```bash
# Install Flask (required for mock server)
pip install flask>=2.0.0
# Start the mock server in a separate terminal
python -m socialseed_e2e.mock_server
```
### 6. Run Tests
```bash
e2e run
```
**Expected Output:**
```
🚀 socialseed-e2e v0.1.4
══════════════════════════════════════════════════
📋 Configuration: e2e.conf
🌍 Environment: dev
Services Summary:
Detected: [demo-api]
Configured: [demo-api]
Running tests for service: demo-api
══════════════════════════════════════════════════
✓ demo-api tests completed
════════════════════════════════════════════════════════════
Test Execution Summary
════════════════════════════════════════════════════════════
demo-api: 1/1 passed (100.0%)
✅ All tests passed!
```
**Note:** If tests fail with "Connection refused", ensure your API server is running before executing `e2e run`.
---
## 📋 System Requirements
Before installing socialseed-e2e, ensure your environment meets the following requirements:
### Python Versions
- **Python >= 3.10** (required)
- Tested on Python 3.10, 3.11, and 3.12
### Operating Systems
- ✅ **Linux** - Fully supported (primary development platform)
- ✅ **macOS** - Fully supported (Intel and Apple Silicon)
- ⚠️ **Windows** - Supported via WSL2 (Windows Subsystem for Linux)
### Browser Dependencies
socialseed-e2e uses **Playwright** for HTTP testing. You need to install browser binaries:
```bash
# After installing socialseed-e2e
playwright install chromium
# Or install with dependencies (recommended for CI/CD)
playwright install --with-deps chromium
```
**Supported Browsers:**
- Chromium (recommended for API testing)
- Firefox (optional)
- WebKit (optional)
### System Dependencies
#### Linux (Ubuntu/Debian)
```bash
# Playwright system dependencies
sudo apt-get update
sudo apt-get install -y libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 \
libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 libxfixes3 \
libxrandr2 libgbm1 libasound2
```
#### macOS
```bash
# No additional system dependencies required
# Playwright will prompt if anything is needed
```
### Docker (Optional)
You can also run socialseed-e2e using Docker:
```bash
# Build the Docker image
docker build -t socialseed-e2e .
# Run tests in container
docker run --rm -v $(pwd):/app socialseed-e2e e2e run
```
**Docker Benefits:**
- Consistent testing environment
- No local Python/Playwright installation needed
- Perfect for CI/CD pipelines
---
## 🐳 Docker Usage
SocialSeed E2E provides an official Docker image for containerized test execution. This is ideal for CI/CD pipelines and environments where you want to avoid installing Python dependencies locally.
### Building the Docker Image
```bash
# Clone or navigate to the project directory
cd socialseed-e2e
# Build the Docker image
docker build -t socialseed-e2e .
```
### Running Tests with Docker
#### Basic Usage
```bash
# Show help
docker run --rm socialseed-e2e --help
# Run all tests (mount your project directory)
docker run --rm -v $(pwd):/app socialseed-e2e run
# Run tests for a specific service
docker run --rm -v $(pwd):/app socialseed-e2e run --service users-api
# Run with verbose output
docker run --rm -v $(pwd):/app socialseed-e2e run --verbose
```
#### Advanced Usage
```bash
# Run with debug mode
docker run --rm -v $(pwd):/app socialseed-e2e run --debug
# Run in boring mode (disable AI features)
docker run --rm -v $(pwd):/app socialseed-e2e run --no-agent
# Generate JUnit report
docker run --rm -v $(pwd):/app -v $(pwd)/reports:/app/reports socialseed-e2e run --report junit
# Run specific test module
docker run --rm -v $(pwd):/app socialseed-e2e run --service auth --module 01_login
```
### Docker in CI/CD
Example GitHub Actions workflow using Docker:
```yaml
name: E2E Tests with Docker
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t socialseed-e2e .
- name: Run E2E tests
run: docker run --rm -v $(pwd):/app socialseed-e2e run --report junit
- name: Upload test results
uses: actions/upload-artifact@v4
with:
name: test-results
path: ./reports/junit.xml
```
### Benefits of Docker Usage
- **No local installation**: No need to install Python, Playwright, or dependencies
- **Consistent environment**: Same environment across dev, CI, and production
- **Isolated execution**: Tests run in a clean, isolated container
- **Easy CI/CD integration**: Simple to integrate with any CI/CD platform
- **Version pinning**: Use specific versions of the framework via Docker tags
---
## 🤖 Built for AI Agents (Recommended)
**This framework was designed from the ground up for AI agents.**
While you can write tests manually, the true power comes from letting AI do the work:
```bash
# 1. Initialize
e2e init
# 2. Tell your AI agent:
# "Read the .agent/ folder and generate tests for my API"
# 3. The AI automatically:
# - Scans your API code
# - Generates complete test suites
# - Uses semantic search to understand your endpoints
# - Creates stateful test chains
```
**AI Features:**
- Auto-generates `project_knowledge.json` from your codebase
- Vector embeddings for semantic search over your API
- RAG-ready retrieval for context-aware test generation
- Structured protocols that AI agents understand
**Don't have an AI agent?** You can write tests manually too—it's still 10x faster than traditional frameworks.
---
## ✨ What You Get
- **CLI scaffolding** - `e2e new-service` and `e2e new-test` commands
- **Auto-discovery** - Tests run in order automatically
- **Stateful chaining** - Share data between tests
- **Built-in mocking** - Test without external dependencies
- **AI Manifest** - Auto-generate API knowledge from code
- **Vector search** - Semantic search over your API (RAG-ready)
---
## 📚 Advanced Usage Examples
Learn how to handle common testing scenarios with these examples:
### [Authorization Headers](examples/advanced_usage/auth_headers_example.py)
- Basic Authentication
- Bearer Token (JWT)
- API Key authentication
- Custom headers
- OAuth 2.0 flow
### [Environment Variables](examples/advanced_usage/env_variables_example.py)
- Loading .env files
- Environment-specific configuration
- Secrets management
- Test data from environment
### [Test Fixtures](examples/advanced_usage/fixtures_example.py)
- Setup/teardown logic
- Sharing state between tests
- Page attributes as fixtures
- Test isolation patterns
- Cleanup strategies
### [Parameterized Tests](examples/advanced_usage/parameterized_tests_example.py)
- Multiple test files
- External test data (JSON, CSV)
- Test data providers
- Dynamic test generation
- pytest parametrize integration
```bash
# Run an example
python3 examples/advanced_usage/auth_headers_example.py
```
---
## 📝 Example Test
```python
# services/users-api/modules/01_login.py
async def run(page):
response = await page.do_login(
email="test@example.com",
password="secret"
)
assert response.status == 200
assert "token" in response.json()
return response
```
---
## ✅ Checklist for Creating Tests
Before creating tests, ensure your service setup follows these conventions:
### Directory Structure
```
services/{service_name}/
├── __init__.py
├── {service_name}_page.py # Must be named EXACTLY like this
├── data_schema.py # Optional: Data models and constants
└── modules/ # Test modules directory
├── 01_login.py
└── __init__.py
```
### Requirements
- [ ] **Directory**: `services/{service_name}/` - Use underscores (e.g., `auth_service`)
- [ ] **Page File**: `{service_name}_page.py` - Must be named exactly like the directory + `_page.py`
- [ ] **Inheritance**: Class must inherit from `BasePage`
- [ ] **Constructor**: Must accept `base_url: str` and call `super().__init__(base_url=base_url)`
- [ ] **Configuration**: The `services` block in `e2e.conf` must match the directory name (hyphens/underscores are normalized)
### Boilerplate: `{service_name}_page.py`
```python
"""Page class for {service_name} API."""
from socialseed_e2e.core.base_page import BasePage
from typing import Optional
class AuthServicePage(BasePage): # Replace AuthService with your service name
"""Page object for auth-service API interactions."""
def __init__(self, base_url: str, **kwargs):
"""Initialize the page with base URL.
Args:
base_url: Base URL for the API (e.g., http://localhost:8080)
**kwargs: Additional arguments passed to BasePage
"""
super().__init__(base_url=base_url, **kwargs)
def do_login(self, email: str, password: str):
"""Execute login request."""
return self.post("/auth/login", json={
"email": email,
"password": password
})
```
### Configuration Example (`e2e.conf`)
```yaml
services:
auth_service: # Matches services/auth_service/ directory
base_url: http://localhost:8080
health_endpoint: /health
```
**Note**: Service names with hyphens (e.g., `auth-service`) are automatically normalized to underscores (`auth_service`) for matching.
---
## 🎯 CLI Commands
### Core Commands
```bash
e2e init [dir] # Initialize project
e2e new-service <name> # Create service structure
e2e new-test <name> # Create test module
e2e run # Run all tests
e2e lint # Validate test files
e2e config # Show configuration
```
### AI Features
```bash
e2e manifest # Generate API knowledge manifest
e2e manifest-query # Query manifest
e2e build-index # Build vector index for semantic search
e2e search "query" # Semantic search (RAG)
e2e retrieve "task" # Retrieve context for task
e2e watch # Auto-update manifest on file changes
e2e discover # Generate AI Discovery Report
e2e generate-tests # Autonomous test generation
e2e plan-strategy # Generate test strategy
e2e autonomous-run # Run tests with AI orchestration
```
### Testing & Debugging
```bash
e2e doctor # Verify installation
e2e deep-scan # Zero-config project mapping
e2e observe # Auto-detect services and ports
e2e debug-execution # Debug failed tests with AI
e2e analyze-flaky # Analyze flaky test patterns
e2e healing-stats # View self-healing statistics
e2e regression # AI regression analysis
e2e semantic-analyze # Semantic drift detection
```
### Performance & Security
```bash
e2e perf-profile # Performance profiling
e2e perf-report # Generate performance report
e2e security-test # AI-driven security fuzzing
e2e red-team assess # Adversarial security testing
```
### Mocking & Recording
```bash
e2e mock-analyze # Analyze external API dependencies
e2e mock-generate <svc> # Generate mock server
e2e mock-run # Run mock servers
e2e mock-validate # Validate API contracts
e2e recorder record # Record API session
e2e recorder replay # Replay session
e2e shadow capture # Capture production traffic
```
### Import & Export
```bash
e2e import postman <file> # Import Postman collection
e2e import openapi <file> # Import OpenAPI spec
e2e import curl <cmd> # Import curl command
e2e gherkin-translate # Convert Gherkin to tests
e2e translate # Natural language to test code
```
### CI/CD & Community
```bash
e2e setup-ci <platform> # Generate CI/CD templates
e2e community templates # List community templates
e2e community plugins # List plugins
```
### Additional Commands
```bash
e2e install-demo # Install demo APIs
e2e install-extras # Install optional dependencies
e2e telemetry # Token usage monitoring
e2e ai-learning feedback # View AI feedback
e2e dashboard # Launch web dashboard
e2e tui # Launch terminal interface
e2e set url <svc> <url> # Configure service URL
e2e --version # Show version
```
### Full Command Reference
See [docs/cli-reference.md](docs/cli-reference.md) for complete documentation.
---
## 🔄 CI/CD Integration
SocialSeed E2E provides ready-to-use CI/CD templates for seamless integration into your pipelines.
### GitHub Actions
The framework includes a pre-configured GitHub Actions workflow at `.github/workflows/e2e.yml`:
```yaml
name: E2E Tests
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
e2e-tests:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '>=3.10'
- name: Install socialseed-e2e
run: pip install socialseed-e2e
- name: Install Playwright Browsers
run: playwright install --with-deps chromium
- name: Run E2E Tests
run: e2e run --report junit
- name: Upload Test Results
uses: actions/upload-artifact@v4
with:
name: junit-test-results
path: ./reports/junit.xml
```
**Features:**
- ✅ Triggers on push/PR to `main` branch
- ✅ Python 3.10+ support
- ✅ Automatic JUnit XML report generation
- ✅ Test artifacts uploaded for 30 days
- ✅ Workflow summary in GitHub Actions UI
### Setup Instructions
1. **Use the built-in template:**
```bash
e2e setup-ci github
```
2. **Or manually copy** the `.github/workflows/e2e.yml` file to your repository
3. **The workflow will automatically:**
- Run on every push/PR to main
- Install socialseed-e2e
- Execute all E2E tests
- Generate JUnit reports
- Upload artifacts for analysis
### Other Platforms
Generate templates for other CI/CD platforms:
```bash
e2e setup-ci gitlab # GitLab CI
e2e setup-ci jenkins # Jenkins
e2e setup-ci azure # Azure DevOps
e2e setup-ci circleci # CircleCI
e2e setup-ci travis # Travis CI
```
---
## 🎯 CLI Reference
Complete reference for all CLI commands and flags.
### Global Options
```bash
e2e --help # Show help message and exit
e2e --version # Show version information
```
### Core Commands
#### `e2e init` - Initialize Project
Initialize a new E2E testing project with directory structure and configuration files.
```bash
e2e init [DIRECTORY] [OPTIONS]
Options:
--force Overwrite existing files
```
**Examples:**
```bash
e2e init # Initialize in current directory
e2e init my-project # Initialize in specific directory
e2e init --force # Overwrite existing files
```
#### `e2e new-service` - Create Service
Create a new service with complete scaffolding (page class, data schema, and modules directory).
```bash
e2e new-service NAME [OPTIONS]
Arguments:
NAME Service name (e.g., users-api, auth_service)
Options:
--base-url TEXT Service base URL (default: http://localhost:8080)
--health-endpoint TEXT Health check endpoint path (default: /health)
```
**Examples:**
```bash
e2e new-service users-api
e2e new-service payment-service --base-url http://localhost:8081
e2e new-service auth-service --base-url http://localhost:8080 --health-endpoint /actuator/health
```
#### `e2e new-test` - Create Test
Create a new test module for an existing service.
```bash
e2e new-test NAME --service SERVICE
Required:
--service TEXT Service name to create test for
```
**Examples:**
```bash
e2e new-test login --service auth-api
e2e new-test create-user --service users-api
```
#### `e2e run` - Execute Tests
Run E2E tests with various filtering and output options.
```bash
e2e run [OPTIONS]
Filtering Options:
-s, --service TEXT Run tests for specific service only
-m, --module TEXT Run specific test module
-t, --tag TEXT Only run tests with these tags (can be used multiple times)
-x, --exclude-tag TEXT Exclude tests with these tags (can be used multiple times)
Configuration Options:
-c, --config TEXT Path to configuration file (default: e2e.conf)
-v, --verbose Enable verbose output with detailed information
Output Options:
-o, --output [text|json|html] Output format (default: text)
--report-dir PATH Directory for HTML reports (default: .e2e/reports)
Report Generation:
--report [junit|json] Generate machine-readable test report
--report-output PATH Directory for reports (default: ./reports)
Debugging:
-d, --debug Enable debug mode with verbose HTTP request/response logging for failed tests
Parallel Execution:
-j, --parallel INTEGER Enable parallel execution with N workers (0=disabled)
--parallel-mode [service|test] Parallel execution mode
Traceability:
-T, --trace Enable visual traceability and generate sequence diagrams
--trace-output PATH Directory for traceability reports
--trace-format [mermaid|plantuml|both] Format for sequence diagrams
```
**Examples:**
```bash
e2e run # Run all tests
e2e run --service auth_service # Run tests for specific service
e2e run --service auth_service --module 01_login # Run specific test module
e2e run --verbose # Run with detailed output
e2e run --output html --report-dir ./reports # Generate HTML report
e2e run --parallel 4 # Run with 4 parallel workers
e2e run --trace # Enable traceability
e2e run -c /path/to/e2e.conf # Use custom config file
e2e run --report junit # Generate JUnit XML report
e2e run --report json # Generate JSON report
e2e run --report junit --report-output ./reports # Custom report directory
e2e run --debug # Enable debug mode with HTTP logging
```
### AI-Powered Commands
#### `e2e manifest` - Generate AI Project Manifest
Generate structured API knowledge from your codebase for AI agents.
```bash
e2e manifest [DIRECTORY]
```
#### `e2e search` - Semantic Search
Search your API endpoints and DTOs using natural language (RAG-ready).
```bash
e2e search QUERY
e2e search "authentication endpoints"
e2e search "user DTO" --type dto
```
#### `e2e build-index` - Build Vector Index
Build vector embeddings index for semantic search.
```bash
e2e build-index
```
#### `e2e deep-scan` - Auto-Discover Project
Zero-config deep scan for automatic project mapping and configuration.
```bash
e2e deep-scan [DIRECTORY]
Options:
--auto-config Automatically configure e2e.conf based on scan results
```
#### `e2e generate-tests` - AI Test Generation
Autonomous test suite generation based on code intent.
```bash
e2e generate-tests [OPTIONS]
Options:
--service TEXT Target service for test generation
--module TEXT Specific module to generate tests for
```
#### `e2e translate` - Natural Language to Test Code
Translate natural language descriptions to test code.
```bash
e2e translate "Create a test that logs in and verifies the token"
```
### CI/CD Commands
#### `e2e setup-ci` - Generate CI/CD Templates
Generate CI/CD pipeline templates for various platforms.
```bash
e2e setup-ci PLATFORM
Platforms:
github GitHub Actions
gitlab GitLab CI
jenkins Jenkins
azure Azure DevOps
circleci CircleCI
travis Travis CI
bitbucket Bitbucket Pipelines
```
**Examples:**
```bash
e2e setup-ci github # Generate GitHub Actions workflow
e2e setup-ci gitlab # Generate GitLab CI configuration
e2e setup-ci jenkins # Generate Jenkinsfile
```
### Utility Commands
#### `e2e config` - Show Configuration
Show and validate current configuration.
```bash
e2e config
```
#### `e2e doctor` - Verify Installation
Verify installation and check dependencies.
```bash
e2e doctor
```
#### `e2e watch` - File Watcher
Watch project files and auto-update manifest on changes.
```bash
e2e watch [DIRECTORY]
```
#### `e2e observe` - Service Discovery
Auto-detect running services and ports.
```bash
e2e observe [DIRECTORY]
Options:
-h, --host TEXT Hosts to scan
-p, --ports TEXT Port range (e.g., 8000-9000)
-t, --timeout FLOAT Timeout for port scanning in seconds
--docker / --no-docker Scan Docker containers
--auto-setup Auto-setup environment using Docker
--dry-run Show what would be done without executing
```
### Getting Help
Use `--help` with any command for detailed information:
```bash
e2e --help
e2e run --help
e2e new-service --help
e2e generate-tests --help
```
---
## 📚 Documentation
All guides at **[daironpf.github.io/socialseed-e2e](https://daironpf.github.io/socialseed-e2e/)**
- **[How it Works](https://daironpf.github.io/socialseed-e2e/how-it-works.html)** - Understanding the core concepts (Service, Endpoint, Scenario, Test)
- [Quick Start](https://daironpf.github.io/socialseed-e2e/quickstart.html)
- [Writing Tests](https://daironpf.github.io/socialseed-e2e/writing-tests.html)
- [CI/CD Integration](https://daironpf.github.io/socialseed-e2e/ci-cd.html)
- [CLI Reference](https://daironpf.github.io/socialseed-e2e/cli-reference.html)
- [AI Manifest](https://daironpf.github.io/socialseed-e2e/project-manifest.html)
---
## 📜 License
MIT - See [LICENSE](LICENSE)
<p align="center">
<sub>Built with ❤️ by Dairon Pérez Frías and AI co-authors</sub>
</p>
| text/markdown | Dairon Pérez Frías | Dairon Pérez Frías <dairon.perezfrias@gmail.com> | null | null | MIT | testing, e2e, api, playwright, rest, grpc, framework | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software Development :: Testing",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"playwright>=1.40.0",
"pydantic>=2.0.0",
"pyyaml>=6.0",
"requests>=2.31.0",
"typing-extensions>=4.8.0",
"click>=8.0.0",
"rich>=13.0.0",
"jsonschema>=4.0.0",
"jinja2>=3.0.0",
"websocket-client>=1.0.0",
"Faker>=19.0.0",
"aiohttp>=3.9.0",
"email-validator>=2.0.0",
"grpcio>=1.59.0; extra == \"grpc\"",
"grpcio-tools>=1.59.0; extra == \"grpc\"",
"protobuf>=4.24.0; extra == \"grpc\"",
"textual>=0.41.0; extra == \"tui\"",
"flask>=2.0.0; extra == \"mock\"",
"sentence-transformers>=2.2.0; extra == \"rag\"",
"numpy>=1.24.0; extra == \"rag\"",
"hvac>=1.0.0; extra == \"secrets\"",
"boto3>=1.26.0; extra == \"secrets\"",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest-xdist>=3.5.0; extra == \"dev\"",
"black>=23.0.0; extra == \"dev\"",
"isort>=5.12.0; extra == \"dev\"",
"flake8>=6.0.0; extra == \"dev\"",
"mypy>=1.0.0; extra == \"dev\"",
"pre-commit>=3.0.0; extra == \"dev\"",
"twine>=4.0.0; extra == \"dev\"",
"build>=0.10.0; extra == \"dev\"",
"grpcio>=1.59.0; extra == \"full\"",
"grpcio-tools>=1.59.0; extra == \"full\"",
"protobuf>=4.24.0; extra == \"full\"",
"textual>=0.41.0; extra == \"full\"",
"flask>=2.0.0; extra == \"full\"",
"sentence-transformers>=2.2.0; extra == \"full\"",
"numpy>=1.24.0; extra == \"full\"",
"hvac>=1.0.0; extra == \"full\"",
"boto3>=1.26.0; extra == \"full\""
] | [] | [] | [] | [
"Homepage, https://github.com/daironpf/socialseed-e2e",
"Documentation, https://github.com/daironpf/socialseed-e2e/tree/main/docs",
"Repository, https://github.com/daironpf/socialseed-e2e",
"Issues, https://github.com/daironpf/socialseed-e2e/issues",
"Changelog, https://github.com/daironpf/socialseed-e2e/blob/main/CHANGELOG.md"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-21T03:54:54.395088 | socialseed_e2e-0.1.5.tar.gz | 1,327,109 | d5/3c/717589b3c37d62afa8671904548289c027b0740bd4301730353600037064/socialseed_e2e-0.1.5.tar.gz | source | sdist | null | false | d478e9d2f6de25150d648ae68332779a | 99021f6d40326af1b35ff15070b52d43dbfd85d1371e0d88e9fe597cdc19f2ea | d53c717589b3c37d62afa8671904548289c027b0740bd4301730353600037064 | null | [
"LICENSE"
] | 458 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.