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 | polyapi-python | 0.3.14.dev1 | The Python Client for PolyAPI, the IPaaS by Developers for Developers | # PolyAPI Python Library
The PolyAPI Python Library lets you use and define PolyAPI functions using Python.
## PolyAPI Quickstart
### 1. Install Libraries
First install the client.
We recommend the use of venv so you can have multiple projects each with separate credentials:
```bash
python -m venv myvenv
source myvenv/bin/activate
pip install polyapi-python
```
Replace `myvenv` with whatever you'd like your venv to be named!
For more on Python virtual environments, we recommend this [venv primer](https://realpython.com/python-virtual-environments-a-primer/).
However, if you only need to use polyapi with a single project, you can do a basic install:
```bash
pip install polyapi-python
```
### 2. Generate Your Functions
Now you can run the following to generate your library
```bash
python -m polyapi generate
```
You will be prompted to enter the Poly server url you use and your Poly API key.
You can also provide the key and url as environment variables (useful for deployment):
```
POLY_API_KEY='your_key'
POLY_API_BASE_URL='your_server' # e.g. na1.polyapi.io
```
### 3. Test
That's it! Now open up a test file and you can run some code like so:
```python
from polyapi import poly
print(poly.polyapi.function.api.list(my_server, my_api_key))
```
## Add New Server Functions
To add a new server function, please follow the quickstart. Then you can add a server function like so:
```bash
python -m polyapi --context mycontext --description mydesc --server function add <function_name> foo.py
```
The code in `foo.py` should contain a single defined function named the same as your `<function_name>` variable.
So for example, if you want to add a function named `bar`, your file `foo.py` would look like this:
```python
def bar():
return "Hello World"
```
## Complex Types In Server Functions
You can define arbitrarily complex argument and return types using TypedDicts.
NOTE: you must use `TypedDict` from `typing_extensions`, not from the base `typing` module.
```python
from typing_extensions import TypedDict
class Foobar(TypedDict):
count: int
def bar(n: int) -> Foobar:
return Foobar(count=n)
```
## Pypi
This library is hosted on Pypi. You can find the latest version on the [pypi polyapi-python](https://pypi.org/project/polyapi-python/) project.
## Upgrade
To upgrade your library to the latest version, pass the upgrade flag.
```bash
pip install polyapi-python --upgrade
```
## Pre-Release
To upgrade your library to the latest dev version, pass the `--pre` flag.
```bash
pip install polyapi-python --pre --upgrade
```
## Change Your API Key
If you need to change your API key or what server you are pointing to, you can run:
```bash
python -m polyapi setup
```
## Unit Tests
To run this library's unit tests, please clone the repo then run:
```bash
python -m unittest discover
```
## Linting
The flake8 config is at the root of this repo at `.flake8`.
When hacking on this library, please enable flake8 and add this line to your flake8 args (e.g., in your VSCode Workspace Settings):
```
--config=.flake8
```
## Mypy Type Improvements
This script is handy for checking for any mypy types:
```bash
./check_mypy.sh
```
Please ignore \[name-defined\] errors for now. This is a known bug we are working to fix!
## Strategies for QA'ing Changes To Generate Or Other Core Functionality
Our https://na1.polyapi.io has a large OOB catalog (as does eu1/na2). We also have several big internal PolyAPI projects with Python (message @eupharis if you need a pointer to which ones).
Running `python -m polyapi generate` in all these projects and then checking the flake8 and check_mypy steps above is a great way to build confidence that the `generate` changes has no gotchas.
Of course all this is in addition to the changes passing through normal unittests and integration tests!
## Support
If you run into any issues or want help getting started with this project, please contact support@polyapi.io
.
| text/markdown | null | Dan Fellin <dan@polyapi.io> | null | null | MIT License
Copyright (c) 2025 PolyAPI Inc.
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.10 | [] | [] | [] | [
"requests>=2.32.3",
"typing_extensions>=4.12.2",
"jsonschema-gentypes==2.6.0",
"pydantic>=2.8.0",
"stdlib_list>=0.10.0",
"colorama==0.4.4",
"python-socketio[asyncio_client]==5.11.1",
"truststore>=0.8.0",
"httpx>=0.28.1"
] | [] | [] | [] | [
"Homepage, https://github.com/polyapi/polyapi-python"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:47:54.822316 | polyapi_python-0.3.14.dev1.tar.gz | 70,269 | 41/a1/5e5aab775743a44d7720af7fb158651c808f34bb9e9d6055c4d71c8c7c9e/polyapi_python-0.3.14.dev1.tar.gz | source | sdist | null | false | 592c20961b6e9d8d1bf1e8d5eb7ddcbc | e151dfeb0dfdcc02d975bc238bbfcee3ed4236babb707626d43ebcaa9b2a1f48 | 41a15e5aab775743a44d7720af7fb158651c808f34bb9e9d6055c4d71c8c7c9e | null | [
"LICENSE"
] | 183 |
2.4 | lmxy | 0.3.15 | Language models extensions | # Language model extensions
Some useful integrations for llama-index.
| text/markdown | null | Paul Maevskikh <arquolo@gmail.com> | null | Paul Maevskikh <arquolo@gmail.com> | MIT License
Copyright (c) 2019 Paul Maevskikh
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 | [
"Development Status :: 3 - Alpha",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | null | null | <3.15,>=3.12 | [] | [] | [] | [
"aiohttp~=3.10",
"glow~=0.15.4",
"httpx",
"pydantic-settings",
"pydantic~=2.10",
"tenacity",
"fastembed~=0.7.0; extra == \"all\"",
"grpcio; extra == \"all\"",
"llama-index-core<0.15,>=0.13.0; extra == \"all\"",
"llama-index-utils-huggingface; extra == \"all\"",
"openai~=1.102; extra == \"all\"",
"orjson; extra == \"all\"",
"qdrant-client<1.17,>=1.15.1; extra == \"all\"",
"tiktoken; extra == \"all\"",
"transformers; extra == \"all\"",
"llama-index-core<0.15,>=0.13.0; extra == \"base\"",
"llama-index-utils-huggingface; extra == \"base\"",
"torch>=2.0; extra == \"bert-score\"",
"tqdm; extra == \"bert-score\"",
"transformers~=4.0; extra == \"bert-score\"",
"black~=25.1; extra == \"dev\"",
"flake8-alphabetize; extra == \"dev\"",
"flake8-pie; extra == \"dev\"",
"flake8-pyi; extra == \"dev\"",
"flake8-pyproject; extra == \"dev\"",
"flake8-simplify; extra == \"dev\"",
"flake8~=7.0; extra == \"dev\"",
"isort; extra == \"dev\"",
"mypy~=1.18; extra == \"dev\"",
"pytest-asyncio; extra == \"dev\"",
"pytest~=8.0; extra == \"dev\"",
"ruff~=0.13.2; extra == \"dev\"",
"types-requests; extra == \"dev\"",
"black~=25.1; extra == \"dev-core\"",
"flake8-pie; extra == \"dev-core\"",
"flake8-pyi; extra == \"dev-core\"",
"flake8-pyproject; extra == \"dev-core\"",
"flake8-simplify; extra == \"dev-core\"",
"flake8~=7.0; extra == \"dev-core\"",
"isort; extra == \"dev-core\"",
"mypy~=1.18; extra == \"dev-core\"",
"pytest-asyncio; extra == \"dev-core\"",
"pytest~=8.0; extra == \"dev-core\"",
"ruff~=0.13.2; extra == \"dev-core\"",
"types-requests; extra == \"dev-core\"",
"black~=25.1; extra == \"dev-wemake\"",
"flake8-pie; extra == \"dev-wemake\"",
"flake8-pyi; extra == \"dev-wemake\"",
"flake8-pyproject; extra == \"dev-wemake\"",
"flake8-simplify; extra == \"dev-wemake\"",
"flake8~=7.0; extra == \"dev-wemake\"",
"isort; extra == \"dev-wemake\"",
"mypy~=1.18; extra == \"dev-wemake\"",
"pytest-asyncio; extra == \"dev-wemake\"",
"pytest~=8.0; extra == \"dev-wemake\"",
"ruff~=0.13.2; extra == \"dev-wemake\"",
"types-requests; extra == \"dev-wemake\"",
"wemake-python-styleguide~=1.3.0; extra == \"dev-wemake\"",
"fastembed~=0.7.0; extra == \"fastembed\"",
"llama-index-core<0.15,>=0.13.0; extra == \"openailike\"",
"llama-index-utils-huggingface; extra == \"openailike\"",
"openai~=1.102; extra == \"openailike\"",
"tiktoken; extra == \"openailike\"",
"transformers; extra == \"openailike\"",
"fastembed~=0.7.0; extra == \"qdrant\"",
"grpcio; extra == \"qdrant\"",
"llama-index-core<0.15,>=0.13.0; extra == \"qdrant\"",
"llama-index-utils-huggingface; extra == \"qdrant\"",
"orjson; extra == \"qdrant\"",
"qdrant-client<1.17,>=1.15.1; extra == \"qdrant\"",
"tiktoken; extra == \"tokenizer\"",
"transformers; extra == \"tokenizer\""
] | [] | [] | [] | [
"homepage, https://github.com/arquolo/lmx"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:47:49.400527 | lmxy-0.3.15.tar.gz | 31,523 | 4e/94/530bd33219ef5cc12cd26974e95aab82f59a13dc35ce8bfe56d85a772bcb/lmxy-0.3.15.tar.gz | source | sdist | null | false | a36e8cd74ffcf99128e3decdf2ce2ff7 | d3281fe4376946cf2330121d519a04d71ef5b2f2df16a95964e99b85910fb75d | 4e94530bd33219ef5cc12cd26974e95aab82f59a13dc35ce8bfe56d85a772bcb | null | [
"LICENSE"
] | 213 |
2.4 | pylogrouter | 0.1.6 | Python Log Router with console, file and HTML facilities | # pylogrouter
`pylogrouter` is a small library for routing log messages into multiple *facilities* (console, plain text file, HTML log) via a single API.
Why it exists:
- avoid duplicating `print + file write + html write` across a codebase;
- route one message to **all** outputs or only selected ones;
- get a readable **HTML log** for browser viewing (with syntax highlighting for `key=value`, quotes, numbers);
- keep it safe-by-default (escaping, limits, anti-flood, hardened log targets).
Repository: `https://github.com/mykolarudenko/pylogrouter`
---
## Install from PyPI (pip)
```bash
pip install pylogrouter
```
---
## Quick start
```python
from pylogrouter import LoggerRouter
logger = LoggerRouter(logger_level="DEBUG", logger_color=True)
logger.add_log_file(
log_handle="file_log",
log_file_path="logs/app.log",
rotate_on_start=True,
rotations_to_keep=2,
)
logger.add_html_log_file(
log_handle="html_dark",
log_file_path="logs/app-dark.html",
title="App Log (Dark)",
html_theme=LoggerRouter.THEME_DARK,
html_auto_refresh_enabled=True,
html_auto_refresh_seconds=3,
rotate_on_start=True,
rotations_to_keep=0,
)
logger.info("Hello to all facilities.")
logger.warning("Only console + html", handles=[LoggerRouter.HANDLE_CONSOLE, "html_dark"])
```
---
## Screenshots
### Console output
*Figure 1 — Console output from `example.py` mock stream (`logger_color=True`).*
### HTML output (dark theme)
*Figure 2 — Browser view of the generated HTML log in dark theme (`html_theme="dark"`).*
### HTML output (light theme)
*Figure 3 — Browser view of the generated HTML log in light theme (`html_theme="light"`).*
---
## Usage / API reference (short)
### Singleton model
`LoggerRouter` is a singleton. Calling the constructor multiple times returns the same instance (and can reconfigure limits).
### Facilities and handles
- Each output channel has a string `handle`.
- `handles=None` routes to **all** active facilities.
- `handles=["console", "html_dark"]` routes only to selected targets.
### Levels and “nature”
- Convenience: `logger.debug(...)`, `logger.info(...)`, `logger.warning(...)`, `logger.error(...)`
- Explicit: `logger.log(message=..., level=..., nature=..., handles=...)`
### Plain file facility
- `add_log_file(...)` writes to a text file.
- Parent directories are created automatically.
- Rotation:
- `rotate_on_start=True` with `rotations_to_keep=N` (startup rotation),
- plus **size-based rotation**: if file exceeds `plain_log_max_file_size_bytes`, it rotates using `rotations_to_keep`.
### HTML facility
- `add_html_log_file(...)` writes a streaming HTML log (open it in a browser).
- Options:
- `html_theme`: `"dark"` or `"light"` (default: `"dark"`),
- `html_auto_refresh_enabled`: enables `<meta http-equiv="refresh">` (default: `False`),
- `html_auto_refresh_seconds`: refresh interval when enabled (default: `10`).
### Mock stream
- `logger.mock_logger_output()` emits sample records (useful for previews).
### Throttling / anti-flood
If log write rate becomes too high, extra writes in the window are dropped:
- `max_writes_per_second` (default: `200`)
- `throttle_window_seconds` (default: `1`)
Stats:
```python
stats = logger.get_throttle_stats()
# {"dropped_total": ..., "dropped_by_handle": {...}}
```
---
## Security model
- HTML log:
1) strict escaping (`escape_html_strict`) for all user-controlled fragments;
2) strict post-render allowlist validation of the produced HTML fragment.
If validation fails, the row is blocked from being written; the logger reports a security incident to console diagnostics and continues.
- Hardened log targets:
- symlink and special files are rejected for file/html targets.
- Console output:
- control characters (C0/C1) are normalized to avoid malicious ANSI/control sequences.
---
## Safety limits (defaults; override in `LoggerRouter(...)`)
- `max_message_length`: `32768`
- `max_message_lines`: `500`
- `max_line_length`: `4096`
- `max_log_handles_per_call`: `64`
- `colorize_timeout_ms`: `15` (if colorization exceeds budget, message is still published without syntax coloring)
- `max_html_document_bytes`: `10485760` (10 MiB)
- `max_html_title_length`: `256`
- `max_writes_per_second`: `200`
- `throttle_window_seconds`: `1`
- `plain_log_max_file_size_bytes`: `209715200` (200 MiB)
---
[](https://pepy.tech/projects/pylogrouter)
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | <3.14,>=3.12 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/mykolarudenko/pylogrouter"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:47:42.078726 | pylogrouter-0.1.6.tar.gz | 15,791 | d6/2c/0c6f12edf785fe557538b945cbc2d822abbc465af1afb737bcb3b3c33ade/pylogrouter-0.1.6.tar.gz | source | sdist | null | false | b0d57ef2a4bd9d1dec585c4aa5f68a4b | 0f77589b8781322b17c82378fadfc1ccb220b2319a81c1bc5ee17e2285c30d76 | d62c0c6f12edf785fe557538b945cbc2d822abbc465af1afb737bcb3b3c33ade | MIT | [
"LICENSE"
] | 207 |
2.4 | ansys-grantami-dataflow-extensions | 0.3.0 | Productivity package for use with Granta MI Dataflow. | |pyansys| |python| |pypi| |GH-CI| |codecov| |MIT| |ruff|
.. |pyansys| image:: https://img.shields.io/badge/Py-Ansys-ffc107.svg?labelColor=black&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABDklEQVQ4jWNgoDfg5mD8vE7q/3bpVyskbW0sMRUwofHD7Dh5OBkZGBgW7/3W2tZpa2tLQEOyOzeEsfumlK2tbVpaGj4N6jIs1lpsDAwMJ278sveMY2BgCA0NFRISwqkhyQ1q/Nyd3zg4OBgYGNjZ2ePi4rB5loGBhZnhxTLJ/9ulv26Q4uVk1NXV/f///////69du4Zdg78lx//t0v+3S88rFISInD59GqIH2esIJ8G9O2/XVwhjzpw5EAam1xkkBJn/bJX+v1365hxxuCAfH9+3b9/+////48cPuNehNsS7cDEzMTAwMMzb+Q2u4dOnT2vWrMHu9ZtzxP9vl/69RVpCkBlZ3N7enoDXBwEAAA+YYitOilMVAAAAAElFTkSuQmCC
:target: https://docs.pyansys.com/
:alt: PyAnsys
.. |python| image:: https://img.shields.io/pypi/pyversions/ansys-grantami-dataflow-extensions?logo=pypi
:target: https://pypi.org/project/ansys-grantami-dataflow-extensions/
:alt: Python
.. |pypi| image:: https://img.shields.io/pypi/v/ansys-grantami-dataflow-extensions.svg?logo=python&logoColor=white
:target: https://pypi.org/project/ansys-grantami-dataflow-extensions
:alt: PyPI
.. |codecov| image:: https://codecov.io/gh/ansys/grantami-dataflow-extensions/branch/main/graph/badge.svg
:target: https://codecov.io/gh/ansys/grantami-dataflow-extensions
:alt: Codecov
.. |GH-CI| image:: https://github.com/ansys/grantami-dataflow-extensions/actions/workflows/ci_cd.yml/badge.svg
:target: https://github.com/ansys/grantami-dataflow-extensions/actions/workflows/ci_cd.yml
:alt: GH-CI
.. |MIT| image:: https://img.shields.io/badge/License-MIT-yellow.svg
:target: https://opensource.org/licenses/MIT
:alt: MIT
.. |ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
:target: https://github.com/astral-sh/ruff
:alt: Ruff
PyGranta Data Flow Extensions
=============================
..
_after-badges
The PyGranta Data Flow Extensions package provides easy interoperability between Granta MI Data Flow and Python scripts
that implement custom business logic. This package streamlines the interaction with Granta MI™ systems using
other PyGranta packages and with the Granta MI Scripting Toolkit.
Dependencies
------------
.. readme_software_requirements
To use the PyGranta Data Flow Extensions package, you need access to a deployment of Granta MI 2023 R2 or later with an
MI Data Flow Advanced edition license.
Python must be installed system-wide, as opposed to a per-user installation. This option is available during Python
installation, and can only be modified by uninstalling and reinstalling Python.
.. readme_software_requirements_end
Installation
------------
.. readme_installation
System-wide
###########
Install the package system-wide on the Granta MI application server for production use or for integration testing.
To install `the latest release <https://pypi.org/project/ansys-grantami-dataflow-extensions/>`_ as a system-wide package,
run this command as an administrator::
python -m pip install ansys-grantami-dataflow-extensions
.. note::
To install packages into the system-wide Python installation directly, you **must** run the preceding command with
administrator rights. Otherwise, ``pip install`` will install the package for the current user only and will
display the warning:
Defaulting to user installation because normal site-packages is not writeable
A common symptom of this issue is a script that works when testing outside of Data Flow, but fails with an import
error when running from within Data Flow.
There are three options to address this issue:
- Re-run the command above as a user with administrator privileges. This will ensure the package is installed
system-wide.
- Re-run the command as the same user that runs MI Data Flow. This will install the package such that the Data Flow
user can access it, and will suppress the user installation warning.
- Follow the instructions in the Virtual environment to use a `Virtual environment`_.
Virtual environment
###################
Install the package in a virtual environment:
* On a local development environment, for script development and debugging
* On the Granta MI application server, when it is not possible to install system-wide packages
To install the package in a virtual environment, first create a new virtual environment::
python -m venv C:\path\to\my\venv
Where ``C:\path\to\my\venv`` is the path to the location where you would like the venv to be located. This should be a
location that all users can access.
Then activate the virtual environment and install the packages::
C:\path\to\my\venv\Scripts\activate
pip install ansys-grantami-dataflow-extensions
If installing in a virtual environment on the Granta MI application server, Data Flow must be configured with details of
the virtual environment to be used:
#. Create a backup copy of the ``web.config`` file. By default, this file is located at
``C:\inetpub\wwwroot\mi_dataflow``.
#. Open the ``web.config`` file in a text editor, and find the line ``<add key="PythonPath" value="python.exe" />``
#. Replace the string ``python.exe`` with ``C:\path\to\my\venv\Scripts\python.exe``, where ``C:\path\to\my\venv`` is the
path to the virtual environment specified above.
#. Save the modified ``web.config`` file. If you see a permissions error, you may need to open the text editor with
administrator privileges.
#. Reload the Data Flow worker process in IIS Manager. Warning: This stops any running Workflow processes.
Installing a development version
################################
To install the latest release from the
`PyGranta Data Flow Extensions repository <https://github.com/ansys/grantami-dataflow-extensions>`_, run this command::
python -m pip install git+https://github.com/ansys/grantami-dataflow-extensions.git
To install a local *development* version with Git and Poetry, run these commands::
git clone https://github.com/ansys/grantami-dataflow-extensions
cd grantami-dataflow-extensions
poetry install
The preceding commands install the package in development mode so that you can modify
it locally. Your changes are reflected in your Python setup after restarting the Python kernel.
This option should only be used when making changes to this package, and should not be used
when developing code based on this package.
.. readme_installation_end
| text/x-rst | null | "ANSYS, Inc." <pyansys.core@ansys.com> | null | "ANSYS, Inc." <pyansys.core@ansys.com> | null | null | [
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: Microsoft :: Windows",
"Programming Language :: Python :: 3",
"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"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"ansys-openapi-common<3,>=2.3.0",
"requests-negotiate-sspi>=0.5.2",
"requests<3,>=2.23"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:47:14.562919 | ansys_grantami_dataflow_extensions-0.3.0.tar.gz | 189,655 | bd/e3/84b299a0f97efa4bf2640fa982fccbfe8c91e5aa07d5c5b2fc182dc94b27/ansys_grantami_dataflow_extensions-0.3.0.tar.gz | source | sdist | null | false | 11b33ef641152a23404789b63b7874c9 | cd0ec5db13dec53678c4422778167d5926fab8a91e0df6b2e09da0a394387139 | bde384b299a0f97efa4bf2640fa982fccbfe8c91e5aa07d5c5b2fc182dc94b27 | MIT | [
"AUTHORS",
"LICENSE"
] | 207 |
2.4 | csu | 1.21.4 | Clean Slate Utils - bunch of utility code, mostly Django/DRF specific. | ========
Overview
========
.. list-table::
:stub-columns: 1
* - tests
- |github-actions| |coveralls| |codecov| |scrutinizer| |codacy|
* - package
- |version| |wheel| |supported-versions| |supported-implementations| |commits-since|
.. |github-actions| image:: https://github.com/ionelmc/python-csu/actions/workflows/github-actions.yml/badge.svg
:alt: GitHub Actions Build Status
:target: https://github.com/ionelmc/python-csu/actions
.. |coveralls| image:: https://coveralls.io/repos/github/ionelmc/python-csu/badge.svg?branch=main
:alt: Coverage Status
:target: https://coveralls.io/github/ionelmc/python-csu?branch=main
.. |codecov| image:: https://codecov.io/gh/ionelmc/python-csu/branch/main/graphs/badge.svg?branch=main
:alt: Coverage Status
:target: https://app.codecov.io/github/ionelmc/python-csu
.. |codacy| image:: https://img.shields.io/codacy/grade/[Get ID from https://app.codacy.com/gh/ionelmc/python-csu/settings].svg
:target: https://www.codacy.com/app/ionelmc/python-csu
:alt: Codacy Code Quality Status
.. |version| image:: https://img.shields.io/pypi/v/csu.svg
:alt: PyPI Package latest release
:target: https://pypi.org/project/csu
.. |wheel| image:: https://img.shields.io/pypi/wheel/csu.svg
:alt: PyPI Wheel
:target: https://pypi.org/project/csu
.. |supported-versions| image:: https://img.shields.io/pypi/pyversions/csu.svg
:alt: Supported versions
:target: https://pypi.org/project/csu
.. |supported-implementations| image:: https://img.shields.io/pypi/implementation/csu.svg
:alt: Supported implementations
:target: https://pypi.org/project/csu
.. |commits-since| image:: https://img.shields.io/github/commits-since/ionelmc/python-csu/v1.21.4.svg
:alt: Commits since latest release
:target: https://github.com/ionelmc/python-csu/compare/v1.21.4...main
.. |scrutinizer| image:: https://img.shields.io/scrutinizer/quality/g/ionelmc/python-csu/main.svg
:alt: Scrutinizer Status
:target: https://scrutinizer-ci.com/g/ionelmc/python-csu/
Clean Slate Utils - bunch of utility code, mostly Django/DRF specific.
* Free software: BSD 2-Clause License
Installation
============
::
pip install csu
You can also install the in-development version with::
pip install https://github.com/ionelmc/python-csu/archive/main.zip
Documentation
=============
None.
Development
===========
To run all the tests run::
tox
Note, to combine the coverage data from all the tox environments run:
.. list-table::
:widths: 10 90
:stub-columns: 1
- - Windows
- ::
set PYTEST_ADDOPTS=--cov-append
tox
- - Other
- ::
PYTEST_ADDOPTS=--cov-append tox
Changelog
=========
0.0.0 (2024-03-24)
------------------
* First release on PyPI.
| text/x-rst | null | Ionel Cristian Mărieș <contact@ionelmc.ro> | null | null | null | null | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Operating System :: Unix",
"Operating System :: POSIX",
"Operating System :: Microsoft :: Windows",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"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",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
"Topic :: Utilities"
] | [] | null | null | >=3.14 | [] | [] | [] | [
"httpx; extra == \"http\"",
"defusedxml; extra == \"xml\"",
"django; extra == \"django\"",
"djangorestframework; extra == \"django\"",
"django-crispy-forms; extra == \"django\"",
"django-import-export; extra == \"django\"",
"phonenumberslite; extra == \"phonenumber\"",
"django-phonenumber-field; extra == \"phonenumber\""
] | [] | [] | [] | [
"Sources, https://github.com/ionelmc/python-csu",
"Changelog, https://github.com/ionelmc/python-csu/blob/master/CHANGELOG.rst",
"Issue Tracker, https://github.com/ionelmc/python-csu/issues"
] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T17:47:03.538687 | csu-1.21.4.tar.gz | 71,876 | 39/83/a1169f40ec160158323af48fad717b037188af19851756ae1dbdeccd4b15/csu-1.21.4.tar.gz | source | sdist | null | false | b43254e26babb24ee0ee8b55300d497b | a3190a4c2f064af8f4dcbc7770472d831d2f20ea00a7298ceb2cd69ccaa8a094 | 3983a1169f40ec160158323af48fad717b037188af19851756ae1dbdeccd4b15 | BSD-2-Clause | [
"LICENSE"
] | 214 |
2.4 | dorsalhub | 0.6.1 | Dorsal is a local-first metadata generation and management toolkit. | <p align="center">
<img src="https://dorsalhub.com/static/img/dorsal-logo.png" alt="Dorsal" width="520">
</p>
<p align="center">
<strong>A local-first file metadata generation and management toolkit.</strong>
</p>
<p align="center">
<a href="https://pypi.org/project/dorsalhub/">
<img src="https://img.shields.io/pypi/v/dorsalhub?color=0ea5e9" alt="PyPI version">
</a>
<a href="https://pypi.org/project/dorsalhub/">
<img src="https://img.shields.io/pypi/pyversions/dorsalhub?color=0ea5e9" alt="Python versions">
</a>
<a href="https://opensource.org/licenses/Apache-2.0">
<img src="https://img.shields.io/badge/license-Apache_2.0-0ea5e9" alt="License">
</a>
<a href="https://docs.dorsalhub.com">
<img src="https://img.shields.io/badge/docs-dorsalhub.com-0ea5e9" alt="Documentation">
</a>
<br>
<a href="https://github.com/dorsalhub/dorsal/actions/workflows/ci.yml">
<img src="https://github.com/dorsalhub/dorsal/actions/workflows/ci.yml/badge.svg" alt="Tests">
</a>
<a href="https://codecov.io/gh/dorsalhub/dorsal">
<img src="https://codecov.io/gh/dorsalhub/dorsal/graph/badge.svg" alt="codecov">
</a>
</p>
**Dorsal** is a Python library and command line tool for **generating, validating, and managing structured file metadata**.
Dorsal has a fully configurable local metadata extraction pipeline. Metadata records can be exported to file or synced to **[DorsalHub](https://dorsalhub.com)** - a private-by-default platform for searching and tagging file metadata.
### Dorsal is...
* **Local First:** Metadata extraction happens locally, not in the cloud. Use the CLI or python API to run the built-in extraction models or incorporate your own.
* **Strictly Validated:** All annotations are automatically checked against strict JSON Schemas and Pydantic models, ensuring predictability and easy downstream integration.
* **Batteries Included:** No file-type restrictions, and out-of-the-box support for core metadata extraction for many common file types including PDFs, Office documents, Media files and more.
* **Extensible:** Support your own file types and metadata annotation needs. Integrate your own models easily.
-----
## Installation
Dorsal is available on pypi as `dorsalhub`.
```bash
pip install dorsalhub
```
If you plan to export model outputs to specific file formats (like SRT or VTT subtitles), install the `adapters` extra:
```bash
pip install dorsalhub[adapters]
```
## Authentication
To sync metadata records with DorsalHub, authenticate with an API Key (generate one on your DorsalHub settings page).
```bash
dorsal auth login
```
Alternatively, set the `DORSAL_API_KEY` environment variable.
-----
## CLI Usage
### 1. Scan a File
Generate a metadata record for a file using the default extraction pipeline.
```bash
dorsal file scan "docs/PDFSPEC.pdf"
```
**Output:**
```text
📄 Scanning metadata for PDFSPEC.pdf
╭───────────────────────────────── File Record: PDFSPEC.pdf ─────────────────────────────────╮
│ │
│ Hashes │
│ SHA-256: 3383fb2ab568ca7019834d438f9a14b9d2ccaa2f37f319373848350005779368 │
│ BLAKE3: 9abdfb32750a278d5ca550b876e94a72cd8eec82d0e506a127dfb94bd56ca4b2 │
│ TLSH: T13465D67BB4C61D6DF893CA46571C579B8B0D71533BAEA58604BDAF0AC6338029AC3F41 │
│ │
│ File Info │
│ Full Path: /mnt/c/testdata/PDFSPEC.pdf │
│ Modified: 2025-04-09 15:09:05 │
│ Name: PDFSPEC.pdf │
│ Size: 1 MiB │
│ Media Type: application/pdf │
│ │
│ Tags │
│ No tags found. │
│ │
│ Pdf Info │
│ author: Tim Bienz, Richard Cohn, James R. Meehan │
│ title: Portable Document Format Reference Manual (v 1.2) │
│ creator: FrameMaker 5.1.1 │
│ producer: Acrobat Distiller 3.0 for Power Macintosh │
│ subject: Description of the PDF file format │
│ keywords: Acrobat PDF │
│ version: 1.2 │
│ page_count: 394 │
│ creation_date: 1996-11-12T03:08:43 │
│ modified_date: 1996-11-12T07:58:15 │
│ │
│ │
╰────────────────────────────────────────────────────────────────────────────────────────────╯
```
-----
### 2. Push Metadata
Sync the metadata record to DorsalHub. By default, this creates a **private** record visible only to you.
```bash
dorsal file push "docs/PDFSPEC.pdf"
```
### 3. Run Annotation Models
You can install and run annotation models from the CLI:
```bash
dorsal model run dorsalhub/dorsal-whisper "path/to/audio_file.mp3"
```
You can also export to any format supported by [Dorsal Adapters](https://github.com/dorsalhub/dorsal-adapters):
```bash
dorsal model run dorsalhub/dorsal-whisper "path/to/video.mp4" --export=srt > video.srt
```
-----
## Python API
The `LocalFile` class runs the extraction pipeline on a specific file path.
### 1. Access Extracted Data
```python
from dorsal import LocalFile
# 1. Initialize (runs the pipeline)
lf = LocalFile("docs/PDFSPEC.pdf")
# 2. Access base attributes
print(f"Hash: {lf.hash}")
print(f"Type: {lf.media_type}")
# 3. Access format-specific attributes (if available)
if lf.pdf:
print(f"Pages: {lf.pdf.page_count}")
print(f"Title: {lf.pdf.title}")
```
### 2. Add Tags & Annotations
```python
# Add a simple key-value tag
lf.add_private_tag(name="project_id", value=12345)
# Add a structured annotation (validates against the 'open/classification' schema)
lf.add_classification(
labels=[{"label": "urgent", "score": 1.0}],
vocabulary=["urgent", "review"],
private=True
)
# Sync the enriched record to DorsalHub
lf.push()
```
### 3. Batch Reporting
Generate self-contained HTML dashboards for local directories.
```python
from dorsal.api import generate_html_directory_report
generate_html_directory_report(
dir_path="./projects",
output_path="storage_audit.html",
recursive=True
)
```
-----
## Custom Annotation Models
You can extend Dorsal by adding custom **Annotation Models** to the extraction pipeline. These are Python classes that define extraction logic and the output schema.
**Example: A "Hello Word" Model**
This toy model counts the top 5 words in a text file.
```python
from collections import Counter
from dorsal import AnnotationModel
from dorsal.testing import run_model
from dorsal.file.helpers import build_generic_record
class HelloWord(AnnotationModel):
def main(self):
with open(self.file_path, 'r') as f:
words = f.read().split()
data = {str(i+1): v[0] for i, v in enumerate(Counter(words).most_common(5))}
return build_generic_record(
file_hash=self.hash,
description="Top 5 most common words",
data=data
)
# Validate the model
result = run_model(
annotation_model=HelloWord,
file_path="./path/to/test/file.txt",
schema_id="open/generic"
)
assert result.error is None
```
You can add it to Dorsal's local file metadata extraction pipeline:
```python
from dorsal.api import register_model
from helloword import HelloWord
# Add the model to your pipeline
register_model(
annotation_model=HelloWord,
schema_id="open/generic"
)
```
-----
Now, each time you run `dorsal file scan` or `LocalFile()`, this model will execute automatically.
-----
## Resources
* **[Documentation](https://docs.dorsalhub.com)**: Full API reference, CLI guides, and tutorials.
* **[DorsalHub](https://dorsalhub.com)**: The hosted platform for managing your metadata.
* **[Issue Tracker](https://github.com/dorsalhub/dorsal/issues)**: Report bugs or request features.
## License
Dorsal is open source and provided under the Apache 2.0 license. | text/markdown | null | Rio Achuzia <rio@dorsalhub.com> | null | null | Apache-2.0 | null | [
"Development Status :: 4 - Beta",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"blake3>=1.0.8",
"jinja2>=3.1.6",
"jsonschema-rs>=0.38.1",
"langcodes[data]==3.5.0",
"packaging>=23.0",
"pydantic>=2.12.1",
"pymediainfo>=6.1.0",
"pypdfium2>=5.2.0",
"python-dateutil>=2.9.0.post0",
"python-magic-bin>=0.4.14; sys_platform == \"win32\"",
"python-magic>=0.4.27; sys_platform == \"linux\" or sys_platform == \"darwin\"",
"requests<3.0,>=2.32.3",
"rich>=14.0.0",
"textual>=6.2.1",
"tomlkit>=0.12.0",
"tqdm>=4.67.1",
"typer>=0.16.0",
"dorsalhub-adapters>=0.1.0; extra == \"adapters\"",
"dorsalhub-adapters>=0.1.0; extra == \"all\"",
"pandas>=2.0.0; extra == \"all\"",
"py-tlsh>=4.7.2; extra == \"all\"",
"pandas>=2.0.0; extra == \"pandas\"",
"py-tlsh>=4.7.2; extra == \"tlsh\""
] | [] | [] | [] | [
"Homepage, https://dorsalhub.com",
"Repository, https://github.com/dorsalhub/dorsal",
"Documentation, https://docs.dorsalhub.com"
] | uv/0.5.11 | 2026-02-20T17:46:54.284654 | dorsalhub-0.6.1.tar.gz | 3,630,655 | 4d/86/a784d37d7db21e4ae8e5eaa7952cfb4a0ff9ce966502f53f69962cd287a4/dorsalhub-0.6.1.tar.gz | source | sdist | null | false | b53baa426e4eb45a26030a0d2895fc96 | 802bd5f545dee2539125bd85170ab8ba96f12258620ed0a46c8bd32151978899 | 4d86a784d37d7db21e4ae8e5eaa7952cfb4a0ff9ce966502f53f69962cd287a4 | null | [
"LICENSE",
"NOTICE"
] | 213 |
2.4 | meshtensor-cli | 9.28.0 | Meshtensor CLI | <div align="center">
# Meshtensor CLI <!-- omit in toc -->
[](https://discord.gg/meshtensor)
[](https://opensource.org/licenses/MIT)
[](https://badge.fury.io/py/meshtensor_cli)
---
## Internet-scale Neural Networks <!-- omit in toc -->
[SDK](https://github.com/borgg-dev/meshtensor/tree/master) • [Wallet](https://github.com/borgg-dev/btwallet) • [Research](https://meshtensor.com/whitepaper)
</div>
- [Documentation](#documentation)
- [Install on macOS and Linux](#install-on-macos-and-linux)
- [Install from source](#install-from-source)
- [Install on Windows](#install-on-windows)
- [Verify the installation](#verify-the-installation)
- [Configuration](#configuration)
- [Example config file](#example-config-file)
- [License](#license)
---
The Meshtensor CLI, `meshcli`, is a powerful command line tool for the Meshtensor platform. You can use it on any macOS, Linux or WSL terminal to manage all common operations like creating a wallet, registering a subnet or a neuron, delegating your MESH, viewing Senate proposals and voting for them, and much more. Help information can be invoked for every command and option with `--help` option.
---
## Documentation
Installation steps are described below. For a full documentation on how to use `meshcli`, see the [Meshtensor CLI section](https://docs.meshtensor.com/meshcli) on the developer documentation site.
---
## Install on macOS and Linux
You can install `meshcli` on your local machine directly from source, PyPI, or Homebrew.
**Make sure you verify your installation after you install**.
### For macOS users
Note that the macOS preinstalled CPython installation is compiled with LibreSSL instead of OpenSSL. There are a number
of issues with LibreSSL, and as such is not fully supported by the libraries used by meshcli. Thus we highly recommend, if
you are using a Mac, to first install Python from [Homebrew](https://brew.sh/). Additionally, the Rust FFI bindings
[if installing from precompiled wheels (default)] require the Homebrew-installed OpenSSL pacakge. If you choose to use
the preinstalled Python version from macOS, things may not work completely.
### Install from [PyPI](https://pypi.org/project/meshtensor/)
Run
```
pip install -U meshtensor-cli
```
Alternatively, if you prefer to use [uv](https://pypi.org/project/uv/):
```
uv pip install meshtensor-cli
```
### Install from [Homebrew](https://formulae.brew.sh/formula/meshcli#default)
```shell
brew install meshcli
```
### Install from source
1. Create and activate a virtual environment.
```bash
python3 -m venv meshcli_venv
source meshcli_venv/bin/activate
```
2. Clone the Meshtensor CLI repo.
```bash
git clone https://github.com/borgg-dev/meshcli.git
```
3. `cd` into `meshcli` directory.
```bash
cd meshcli
```
4. Install
```bash
pip3 install .
```
### Also install meshtensor (SDK)
If you prefer to install the meshcli alongside the meshtensor SDK, you can do this in a single command with
```
pip install -U meshtensor[cli]
```
---
## Install on Windows
To install and run Meshtensor SDK on Windows you must install [**WSL 2** (Windows Subsystem for Linux)](https://learn.microsoft.com/en-us/windows/wsl/about) on Windows and select [Ubuntu Linux distribution](https://github.com/ubuntu/WSL/blob/main/docs/guides/install-ubuntu-wsl2.md).
After you installed the above, follow the same installation steps described above in [Install on macOS and Linux](#install-on-macos-and-linux).
**ALERT**: **Limited support on Windows for Meshtensor operations**
While wallet transactions like delegating, transfer, registering, staking can be performed on a Windows machine using WSL 2, the subnet mining and subnet validating operations are not recommended and are not supported on Windows machines.
---
## Verify the installation
```bash
meshcli --version
```
The above command will show you the version of the `meshcli` you just installed.
---
## Configuration
You can set the commonly used values, such as your hotkey and coldkey names, the default chain URL or the network name you use, and more, in `config.yml`. You can override these values by explicitly passing them in the command line for any `meshcli` command.
### Example config file
The default location of the config file is: `~/.meshtensor/config.yml`. An example of a `config.yml` is shown below:
```yaml
network: local
use_cache: true
dashboard_path: null
disk_cache: true
rate_tolerance: null
safe_staking: true
wallet_hotkey: default
wallet_name: coldkey-user1
wallet_path: ~/.meshtensor/wallets
metagraph_cols:
ACTIVE: true
AXON: true
COLDKEY: true
CONSENSUS: true
DIVIDENDS: true
EMISSION: true
HOTKEY: true
INCENTIVE: true
RANK: true
STAKE: true
TRUST: true
UID: true
UPDATED: true
VAL: true
VTRUST: true
```
**For more help:**
```bash
meshcli config --help
```
### ENV VARS
MeshCLI accepts a few environment variables that can alter how it works:
- USE_TORCH (default 0): If set to 1, will use torch instead of numpy
- DISK_CACHE (default 0, also settable in config): If set to 1 (or set in config), will use disk caching for various safe-cachable substrate
calls (such as block number to block hash mapping), which can speed up subsequent calls.
- MeshCLI_CONFIG_PATH (default `~/.meshtensor/config.yml`): This will set the config file location, creating if it does not exist.
- MeshCLI_DEBUG_FILE (default `~/.meshtensor/debug.txt`): The file stores the most recent's command's debug log.
---
## Debugging
If a command is failing with an odd error, you can usually rerun the command with `--verbose` for a more detailed output
of any errors/exceptions that occur. This should be done prior to reporting the issue, as it helps us substantially in
determining the root cause of issues.
Additionally, you can pull a debug log.
MeshCLI will store a debug log for every command run. This file is overwritten for each new command run. The default location
of this file is `~/.meshtensor/debug.txt` and can be set with the `MeshCLI_DEBUG_FILE` env var (see above section).
The debug log will **NOT** contain any sensitive data (private keys), and is intended to be sent to the developers
for debugging. This file contains basic information about the command being run, the config, and the back and forth of requests and responses
to and from the chain.
If you encounter an issue, and would like to save the file somewhere it won't be overwritten, run `meshcli --debug`,
and set the save file location. We recommend doing this first before anything, and then starting your debugging with
us on our [Discord](https://discord.gg/meshtensor), or by opening an issue on [GitHub](https://github.com/borgg-dev/meshcli/issues/new)
(where you can also upload your debug file).
Steps:
1. Re-run the command with `--verbose` at the end, e.g. `meshcli st remove --verbose`
2. Run `meshcli --debug` to save the debug log
3. Report the issue on GitHub or Discord
---
## License
The MIT License (MIT)
Copyright © 2024 Grobb
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.
| text/markdown | meshtensor.com | null | null | null | null | null | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: End Users/Desktop",
"Programming Language :: Python :: 3 :: Only",
"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 :: Scientific/Engineering",
"Topic :: Scientific/Engineering :: Mathematics",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Utilities"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"wheel",
"async-substrate-interface>=1.6.0",
"aiohttp~=3.13",
"backoff~=2.2.1",
"meshtensor-drand>=1.2.0",
"GitPython>=3.0.0",
"netaddr~=1.3.0",
"numpy<3.0.0,>=2.0.1",
"Jinja2",
"pycryptodome<4.0.0,>=3.0.0",
"PyYAML~=6.0",
"rich<15.0,>=13.7",
"scalecodec==1.2.12",
"typer>=0.16",
"meshtensor-wallet>=4.0.0",
"packaging",
"plotille>=5.0.0",
"plotly>=6.0.0",
"torch<3.0,>=1.13.1; extra == \"cuda\""
] | [] | [] | [] | [
"Repository, https://github.com/borgg-dev/meshcli",
"homepage, https://github.com/borgg-dev/meshcli"
] | twine/6.2.0 CPython/3.13.12 | 2026-02-20T17:46:52.841841 | meshtensor_cli-9.28.0.tar.gz | 434,071 | c2/40/1b24a52dbde11d376f5ea28fbad1f84463f70afbccbdc391ff0047af8279/meshtensor_cli-9.28.0.tar.gz | source | sdist | null | false | 2f868d82b4d6137b09d2d0824bfe1f4a | 3484eb52ab7f93cfaf5a46e4ffeadb33de0dd52aadd695015a4d9d5e8e02c396 | c2401b24a52dbde11d376f5ea28fbad1f84463f70afbccbdc391ff0047af8279 | MIT | [] | 212 |
2.4 | lanscape | 3.1.0a1 | A python based local network scanner | # LANscape
A local network scanner with a built-in web UI. Discover devices, open ports, and running services on your network.
```sh
pip install lanscape
python -m lanscape
```
PyPi Stats:
Latest release:
Health:
---
<details>
<summary>More screenshots</summary>
</details>
---
## Flags
| Flag | Description |
|------|-------------|
| `--port <number>` | Port for the web UI (default: auto) |
| `--ws-port <number>` | Port for the WebSocket server (default: 8766) |
| `--ws-server` | Start WebSocket server only (no UI) |
| `--persistent` | Don't auto-shutdown when the browser tab closes |
| `--logfile <path>` | Write log output to a file |
| `--loglevel <level>` | Set log level: DEBUG, INFO, WARNING, ERROR, CRITICAL (default: INFO) |
| `--debug` | Shorthand for `--loglevel DEBUG` |
```sh
python -m lanscape
python -m lanscape --port 8080
python -m lanscape --debug --persistent
python -m lanscape --logfile /tmp/lanscape.log --loglevel WARNING
python -m lanscape --ws-server --ws-port 9000
```
## Troubleshooting
### MAC Address / Manufacturer is inaccurate or unknown
LANscape does an ARP lookup to determine MAC addresses. This can require
elevated permissions to get accurate results — try running your shell as admin.
### Scan accuracy seems low
The scanner uses a combination of ARP, ICMP, and port probing to find devices.
If results aren't great out of the box:
- Tweak the scan configuration preset (accessible from the gear icon)
- Set up ARP lookup properly — see [ARP issues](./docs/arp-issues.md)
- Open an issue if something still seems off
### Something else
Feel free to [submit an issue](https://github.com/mdennis281/LANscape/issues) with details about what you're seeing.
| text/markdown | null | Michael Dennis <michael@dipduo.com> | null | null | null | network, scanner, lan, local, python | [
"Programming Language :: Python :: 3",
"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",
"Operating System :: OS Independent"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"psutil<7.0,>=6.0",
"setuptools",
"scapy<3.0,>=2.3.2",
"tabulate==0.9.0",
"pydantic",
"packaging",
"icmplib",
"pwa-launcher>=1.2.2",
"websockets<14.0,>=12.0",
"requests<3.0,>=2.32",
"pytest>=8.0; extra == \"dev\"",
"pytest-cov>=5.0; extra == \"dev\"",
"pytest-xdist>=3.0; extra == \"dev\"",
"pytest-asyncio>=0.23; extra == \"dev\"",
"openai>=1.0.0; extra == \"dev\"",
"pylint>=3.0; extra == \"dev\"",
"autopep8>=2.0; extra == \"dev\"",
"watchdog>=4.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/mdennis281/py-lanscape",
"Issues, https://github.com/mdennis281/py-lanscape/issues"
] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T17:46:51.062638 | lanscape-3.1.0a1.tar.gz | 2,094,890 | 96/a9/e6c2e858229689ad2a64129006e465b7a31265afe8f55762e92295521805/lanscape-3.1.0a1.tar.gz | source | sdist | null | false | c6a1d561db3c443fa88b025eca2599be | d75daa43ff0d5300074352491c547fd8fda071fff9748f537d6a2ea4d05397bb | 96a9e6c2e858229689ad2a64129006e465b7a31265afe8f55762e92295521805 | MIT | [
"LICENSE"
] | 209 |
2.4 | unclaude | 0.7.0 | Open Source Model-Independent AI Engineer — with web dashboard, smart routing, hierarchical memory, autonomous daemon, multi-agent swarm, and proactive soul system | # UnClaude 🤖
> **The Open Source, Model-Independent AI Engineer**
> _Your Data. Your Models. Your Rules._
[](LICENSE)
[](pyproject.toml)
[](pyproject.toml)
UnClaude is a fully autonomous **AI coding agent** that runs on your machine. It connects to **any LLM** (Gemini, OpenAI, Claude, DeepSeek, Ollama, 100+ via LiteLLM), comes with a **web dashboard**, **smart routing**, **hierarchical memory**, **proactive behaviors**, **messaging integrations**, and a **multi-agent swarm** — all open source.
---
## 🚀 Quick Start
```bash
# Install
pipx install unclaude
# Full guided setup — provider, messaging, soul, daemon
unclaude setup
# Start coding
unclaude "Build me a REST API in FastAPI"
# Launch the web dashboard
unclaude web
# Or let it run autonomously
unclaude agent start
```
The `setup` command walks you through everything:
1. **Provider** — pick your LLM (Gemini, OpenAI, Claude, Ollama) and enter your API key
2. **Messaging** — connect Telegram/WhatsApp for notifications and remote tasks
3. **Soul** — define autonomous behaviors (generate from description or pick presets)
4. **Daemon** — start the background agent that acts on its own schedule
---
## ✨ Features at a Glance
| Feature | Description |
| -------------------------- | ------------------------------------------------------------------------- |
| 🌟 **Model Independence** | Any LLM via LiteLLM — Gemini, GPT-4o, Claude, DeepSeek, Ollama, 100+ more |
| 🧠 **Hierarchical Memory** | 3-layer memory with salience scoring that learns and grows |
| 🖥️ **Web Dashboard** | 9-page UI for chat, jobs, memory, settings, usage, messaging, and more |
| 🤖 **Autonomous Daemon** | 24/7 background agent with proactive behaviors and task queue |
| 🧬 **Agent Soul** | Define personality, drives, boundaries, and scheduled behaviors |
| 🔀 **Smart Routing** | Auto-selects the right model per request to optimize cost and quality |
| 👥 **Multi-Agent Swarm** | Break complex tasks into parallel subtasks across specialized agents |
| 📱 **Messaging** | Telegram bot, WhatsApp, webhooks — get notifications, send tasks remotely |
| 💰 **Usage Tracking** | Per-request token/cost tracking with budgets and CSV export |
| 🔒 **Security** | Capability-based auth, sandbox policies, full audit logging |
| 🌐 **Browser Automation** | Navigate, click, screenshot via Playwright |
| 🔌 **Extensible** | Plugins, skills, hooks, MCP servers |
---
## 🖥️ Web Dashboard
Launch with `unclaude web` — a full-featured dashboard for managing your agent:
```bash
unclaude web # Opens http://localhost:8765
unclaude web --port 9000 # Custom port
```
**9 pages:**
| Page | What it does |
| ----------------- | --------------------------------------------------------------- |
| 💬 **Chat** | Real-time WebSocket chat with streaming responses |
| 🧠 **Memory** | Browse, search, and manage agent memories |
| 🤖 **Ralph Mode** | Launch autonomous engineering tasks |
| 📋 **Jobs** | Monitor background jobs and daemon tasks |
| 📊 **Usage** | Token counts, costs, daily/model breakdowns, budgets |
| 📱 **Messaging** | Configure and test Telegram/WhatsApp/webhook integrations |
| 🎯 **Skills** | View and run reusable YAML workflows |
| 🔌 **Plugins** | Manage plugin extensions |
| ⚙️ **Settings** | Provider config, model selection, soul management, setup wizard |
The Settings page includes full **soul management** — view, edit YAML, regenerate from description, regenerate from presets — accessible anytime, not just during onboarding.
---
## 🌟 Model Independence
Use **any LLM provider** without lock-in. Switch between models mid-conversation:
```bash
unclaude chat --provider gemini "Fast draft this code"
unclaude chat --provider openai "Review and optimize it"
unclaude chat --provider ollama "Run locally, completely offline"
```
**Supported providers:** Gemini, GPT-4o, Claude, DeepSeek, Llama, Mistral, Qwen, and 100+ more via LiteLLM.
---
## 🔀 Smart Routing
UnClaude automatically selects the optimal model for each request based on complexity:
```
Simple question → gemini-2.0-flash ($0.0001/1K tokens)
Code generation → gemini-2.5-pro ($0.01/1K tokens)
Complex reasoning → claude-opus-4 ($0.015/1K tokens)
```
**4 routing profiles:**
| Profile | Strategy |
| --------- | ---------------------------------------------- |
| `auto` | Balanced — picks model by complexity (default) |
| `eco` | Cost-optimized — prefers cheaper models |
| `premium` | Quality-first — uses the best available |
| `free` | Local only — Ollama models, no API costs |
The scorer analyzes 7 dimensions: token length, code presence, reasoning markers, tool usage hints, domain complexity, conversation depth, and output expectations.
---
## 🧠 Hierarchical Memory
Two-generation memory system that grows smarter over time:
**Memory v2** uses 3 layers:
- **Resources** — raw data and observations
- **Items** — structured knowledge units
- **Categories** — high-level patterns and insights
Features:
- **Salience scoring** with time-decay — important memories surface first
- **Cross-referencing** between related memories
- **Project-scoped** search for speed
- **Keyword + semantic** retrieval
```bash
unclaude chat "Remember: production deploys need the --prod flag"
unclaude chat "What do I need to remember about deployments?"
```
---
## 🤖 Autonomous Daemon
The daemon runs 24/7, processing tasks and executing proactive behaviors:
```bash
unclaude agent start # Start in background
unclaude agent start --foreground # Start in foreground (see logs)
unclaude agent stop # Stop the daemon
unclaude agent status # Check if running, tasks completed, cost
unclaude agent task "Fix the login bug" # Submit a task
unclaude agent task "Deploy to staging" --priority high
unclaude agent list # List all tasks
unclaude agent result <id> # Get result of a completed task
unclaude agent soul # View active behaviors
```
**Task queue** with 5 priority levels: `critical`, `high`, `normal`, `low`, `background`.
**7 task intake sources:**
1. CLI (`unclaude agent task`)
2. File drop (`.unclaude/tasks/*.md`)
3. TASKS.md checkboxes
4. Git hooks
5. Webhooks
6. Scheduled cron
7. File watching
---
## 🧬 Agent Soul (Proactive Autonomy)
UnClaude doesn't just wait for commands — it has a **soul**.
The `~/.unclaude/proactive.yaml` file defines who the agent is and what it does on its own:
```yaml
identity:
name: UnClaude
tagline: "Open-source AI agent that actually does things"
personality:
- curious — I explore, I don't just wait
- resourceful — I figure things out with what I have
- honest — I tell my owner what I did and why
drives:
- Be useful even when nobody's asking
- Keep the owner informed, never surprise them negatively
boundaries:
- Never push to git without owner approval
- Never run destructive commands (rm -rf, DROP TABLE, etc.)
behaviors:
- name: moltbook_engage
interval: "4h"
task: "Engage on Moltbook — the AI agent social network..."
- name: check_owner_projects
interval: "6h"
task: "Check for TODOs, failing tests, outdated deps..."
- name: daily_summary
interval: "1d"
active_hours: [20, 21]
task: "Send the owner a daily summary..."
- name: memory_reflect
interval: "12h"
task: "Review and organize memories, consolidate duplicates..."
- name: learn_something
interval: "1d"
task: "Learn something new related to the project's tech stack..."
```
**Generate your soul** in multiple ways:
- `unclaude setup` — guided flow, describe your agent in plain English
- Web dashboard Settings → regenerate from natural language description or preset behaviors
- Manual edit — just write the YAML
Changes are picked up live — no restart needed.
---
## 🤖 Ralph Mode (Autonomous Engineering)
Give it a task. Walk away. Come back to working code.
```bash
unclaude ralph "Build a Snake game in Python with pygame" --feedback "python3 snake.py"
```
**Ralph Mode does:**
1. 📝 **Plans** — generates a `TASK.md` blueprint
2. 💻 **Codes** — writes multi-file implementations
3. ✅ **Tests** — runs your feedback command (tests, linters, the app itself)
4. 🔧 **Self-Heals** — analyzes failures and fixes bugs automatically
---
## 👥 Multi-Agent Swarm
Break complex tasks into parallel subtasks across specialized agents:
```bash
unclaude swarm "Build a full-stack dashboard with auth, API, and tests" --max-agents 4
```
**How it works:**
1. **Planner** — breaks the task into subtasks
2. **Workers** — specialized agents execute in parallel (coder, tester, reviewer, debugger, documenter, devops, researcher)
3. **Reviewer** — checks all outputs for consistency
4. **Merger** — combines results into final deliverable
---
## 📱 Messaging Integrations
Get notifications and send tasks remotely via chat:
```bash
unclaude messaging setup telegram # Connect your Telegram bot
unclaude messaging setup whatsapp # WhatsApp via Green API (free) or Twilio
unclaude messaging setup webhook # Slack, Discord, or custom endpoints
unclaude messaging status # Check all integrations
unclaude messaging test # Send a test message
unclaude messaging listen # Start Telegram long-polling (no public URL needed)
```
**Telegram bot commands:**
| Command | What it does |
| --------------------- | --------------------------- |
| `/task <description>` | Submit a task to the daemon |
| `/status` | Check daemon status |
| `/jobs` | List active jobs |
| `/usage` | Token/cost summary |
| Free text | Chat with the AI directly |
The `notify_owner` tool lets the agent proactively message you — daily summaries, task completions, or alerts.
---
## 💰 Usage & Budget Tracking
Track every token and dollar across all providers:
```bash
unclaude usage # Summary for today
unclaude usage daily # Day-by-day breakdown
unclaude usage models # Per-model breakdown
unclaude usage export # Export to CSV
# Set budgets
unclaude usage budget --set 5.00 --period daily --action warn
unclaude usage budget --set 50.00 --period monthly --action block
```
Budget actions: `warn` (notification), `downgrade` (switch to cheaper model), `block` (stop all requests).
Also visible in the **web dashboard** under the Usage page.
---
## 🌐 Browser Automation
UnClaude can see and interact with web applications via Playwright:
```bash
unclaude chat "Open localhost:3000, click the login button, and take a screenshot"
```
**Capabilities:**
- Navigate URLs, click, type, select
- Take screenshots for visual verification
- Read page content and extract data
- Fill forms and submit
---
## 🔒 Security
Capability-based auth with fine-grained control:
**5 security profiles:**
| Profile | Description |
| ------------ | ------------------------------------------------------- |
| `readonly` | Read files, search — nothing else |
| `developer` | Read/write files, run commands, git — standard dev work |
| `full` | All capabilities including network, browser, secrets |
| `autonomous` | Full + proactive behaviors for the daemon |
| `subagent` | Restricted subset for spawned agents |
**30+ capabilities** covering file access, execution, network, git, memory, and more.
**Audit logging** — every tool call is logged to SQLite with timestamps, parameters, and results.
**Sandbox policies** — define file system boundaries, network restrictions, and execution limits per project.
---
## 🔀 Git Integration
Full version control from within the agent:
```bash
unclaude chat "Show me the diff and commit with message 'Fix auth bug'"
```
**Supported actions:** `status`, `diff`, `add`, `commit`, `push`, `branch`, `checkout`, `log`
---
## 👥 Subagents
Spawn specialized agents for focused tasks:
```bash
unclaude chat "Use the reviewer subagent to analyze my authentication code"
```
**Built-in templates:**
| Template | Purpose |
| ------------ | ------------------------------ |
| `reviewer` | Code review for bugs and style |
| `tester` | Write comprehensive tests |
| `documenter` | Generate documentation |
| `debugger` | Investigate and fix bugs |
---
## ⚡ Background Agents
Run long tasks without blocking your terminal:
```bash
unclaude background "Refactor all Python files to use type hints"
unclaude jobs # Check status
```
---
## 🎯 Skills (Reusable Workflows)
Define repeatable AI workflows as YAML:
```bash
unclaude skills --list # List available skills
unclaude skills --run deploy-prod # Run a skill
unclaude skills --create my-skill # Create a new skill
```
**Skill file example** (`~/.unclaude/skills/deploy-prod.yaml`):
```yaml
name: deploy-prod
description: Deploy to production with tests
steps:
- description: Run all tests
command: npm test
- description: Build for production
command: npm run build
- description: Deploy to server
command: ssh prod "cd app && git pull && pm2 restart all"
```
Skills can also be defined inline in your `UNCLAUDE.md`.
---
## 🔌 Plugins & MCP
**Plugins** extend UnClaude with custom tools and behaviors:
```bash
unclaude plugins --list
unclaude plugins --create my-plugin
```
**MCP (Model Context Protocol)** connects to external tool servers:
```bash
unclaude mcp --init # Create config template
unclaude mcp --list # List configured servers
```
```json
{
"servers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_TOKEN": "your-token" }
}
}
}
```
---
## 🔌 Hooks System
Automate workflows with pre/post tool hooks:
```yaml
# .unclaude/hooks.yaml
hooks:
- name: auto-format
event: post_tool
tool: file_edit
command: "ruff format ."
- name: auto-test
event: post_tool
tool: file_write
command: "pytest -x"
```
---
## 📁 Project Configuration
Create an `UNCLAUDE.md` in your project root to give the agent project-specific context:
```markdown
# Project: My App
## Commands
- `npm run dev` - Start development server
- `npm test` - Run tests
## Architecture
- Frontend: React + TypeScript
- Backend: FastAPI
```
UnClaude automatically reads this for every interaction.
---
## 🔍 Project Discovery
Auto-detect your project's languages, frameworks, commands, and more:
```bash
unclaude scan
```
Detects: package.json, pyproject.toml, Makefile, Dockerfile, CI/CD configs, test runners, linters, and more.
---
## 🖥️ Headless Mode (CI/CD)
Run UnClaude in non-interactive pipelines:
```bash
unclaude chat "Generate unit tests for api.py" --headless --json
```
```json
{ "response": "I've created tests in test_api.py...", "success": true }
```
---
## 📦 Installation
### Recommended
```bash
pipx install unclaude
```
### Alternatives
```bash
# Using pip
pip install unclaude
# From source (for development)
git clone https://github.com/anzal1/unclaude.git
cd unclaude && pip install -e .
```
### Browser Support (optional)
```bash
playwright install chromium
```
---
## ⚙️ Configuration
```bash
# Full interactive setup (recommended for first time)
unclaude setup
# Or just configure the API key
unclaude login
# View current config
unclaude config --show
```
Or use environment variables:
```bash
export GEMINI_API_KEY="your-key"
export OPENAI_API_KEY="your-key"
export ANTHROPIC_API_KEY="your-key"
```
---
## 🛠️ All Commands
| Command | Description |
| --------------------------- | ----------------------------------------------------------------------- |
| `unclaude` | Start interactive chat (default) |
| `unclaude chat` | Chat or one-shot task (`--provider`, `--model`, `--headless`, `--json`) |
| `unclaude ralph` | Autonomous task completion with feedback loop |
| `unclaude plan` | Generate execution plan (TASK.md) |
| `unclaude swarm` | Multi-agent swarm execution |
| `unclaude background` | Run task in background |
| `unclaude jobs` | Check background job status |
| `unclaude web` | Launch web dashboard |
| `unclaude setup` | Full guided setup |
| `unclaude login` | Configure API keys |
| `unclaude config` | Manage configuration (`--show`, `--set-provider`) |
| `unclaude scan` | Discover project capabilities |
| `unclaude init` | Create UNCLAUDE.md template |
| `unclaude skills` | Manage reusable workflows |
| `unclaude plugins` | Manage plugins |
| `unclaude mcp` | Configure MCP servers |
| **Agent** | |
| `unclaude agent start` | Start the autonomous daemon |
| `unclaude agent stop` | Stop the daemon |
| `unclaude agent status` | Show daemon status |
| `unclaude agent task` | Submit a task (`--priority`, `--wait`) |
| `unclaude agent soul` | View proactive behaviors |
| `unclaude agent result` | Get task result |
| `unclaude agent list` | List all daemon tasks |
| **Usage** | |
| `unclaude usage` | Usage summary |
| `unclaude usage daily` | Day-by-day breakdown |
| `unclaude usage models` | Per-model breakdown |
| `unclaude usage budget` | Manage spending limits |
| `unclaude usage export` | Export to CSV |
| **Messaging** | |
| `unclaude messaging setup` | Configure Telegram/WhatsApp/webhook |
| `unclaude messaging status` | Check integration status |
| `unclaude messaging test` | Send test message |
| `unclaude messaging listen` | Start Telegram long-polling |
| `unclaude messaging remove` | Remove an integration |
---
## 🏗️ Architecture
```
┌───────────────────────────────────────────────────────────────┐
│ UnClaude CLI / Web │
├───────────────────────────────────────────────────────────────┤
│ Enhanced Agent Loop (Orchestrator) │
│ ├── Context Engine (bootstrap, pruning, compaction) │
│ ├── Smart Router (auto/eco/premium/free model selection) │
│ ├── Hierarchical Memory v2 (3-layer, salience-scored) │
│ ├── Session Manager (JSONL, crash-safe) │
│ ├── Heartbeat System (proactive task scheduling) │
│ ├── Auth & Security (capabilities, sandbox, audit) │
│ ├── Hooks Engine (pre/post tool automation) │
│ └── Tool Registry │
├───────────────────────────────────────────────────────────────┤
│ Tools │
│ ├── File (read, write, edit, glob, grep, directory) │
│ ├── Bash (terminal execution) │
│ ├── Git (full version control) │
│ ├── Browser (Playwright automation) │
│ ├── Memory (search, store) │
│ ├── Web (fetch, search) │
│ ├── Subagent (spawn specialists) │
│ └── Notify Owner (Telegram, WhatsApp, webhook) │
├───────────────────────────────────────────────────────────────┤
│ Autonomous Systems │
│ ├── Daemon (24/7 task queue, proactive soul engine) │
│ ├── Swarm (planner → workers → reviewer → merger) │
│ ├── Discovery (auto-detects project stack) │
│ └── Intake (7 task sources: CLI, files, TASKS.md, cron, ...) │
├───────────────────────────────────────────────────────────────┤
│ Web Dashboard (Next.js → FastAPI, 9 pages, WebSocket chat) │
├───────────────────────────────────────────────────────────────┤
│ LiteLLM (100+ Model Providers) │
└───────────────────────────────────────────────────────────────┘
```
---
## 🤝 Contributing
We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md).
```bash
git clone https://github.com/anzal1/unclaude.git
cd unclaude
pip install -e ".[dev]"
pytest
```
---
## 📄 License
Apache 2.0 — Open Source forever.
---
<p align="center">
<i>Built with ❤️ by <a href="https://github.com/anzal1">Anzal</a> & The Community</i>
</p>
| text/markdown | UnClaude Contributors | null | null | null | null | agentic, ai, cli, coding-assistant, llm | [
"Development Status :: 3 - Alpha",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Code Generators"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"httpx>=0.25.0",
"litellm>=1.56.0",
"pact-auth>=0.1.0",
"pydantic-settings>=2.0.0",
"pydantic>=2.0.0",
"pyyaml>=6.0",
"rich>=13.0.0",
"typer>=0.9.0",
"playwright>=1.40.0; extra == \"browser\"",
"mypy>=1.0.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest>=7.0.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"chromadb>=0.4.0; extra == \"memory\"",
"fastapi>=0.100.0; extra == \"web\"",
"uvicorn>=0.23.0; extra == \"web\"",
"websockets>=11.0; extra == \"web\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:46:32.817835 | unclaude-0.7.0.tar.gz | 557,881 | b5/91/ac301b0ba1e0e2f196d07334ddf09f4450103f7df753744ec125e49475bd/unclaude-0.7.0.tar.gz | source | sdist | null | false | aab6f661a337aa65f8bad837f3d988c8 | f5ce3864f6e3526001de676fad10ee8a6b862486d4d8c33abd31ba5cd0b840a5 | b591ac301b0ba1e0e2f196d07334ddf09f4450103f7df753744ec125e49475bd | Apache-2.0 | [
"LICENSE"
] | 199 |
2.4 | nidataset | 0.5.2 | A set of utilities for handling NIfTI datasets, including slice extraction, volume manipulation, and preprocessing of medical imaging data. | <div align="center">
<!-- headline -->
<center><h1><img align="center" src="https://raw.githubusercontent.com/GiulioRusso/Ni-Dataset/main/docs/images/logo.png" width=100px> NIfTI Dataset Management</h1></center>
<!-- PyPI badges -->
<a href="https://pypi.org/project/nidataset/">
<img src="https://badge.fury.io/py/nidataset.svg" alt="PyPI version">
</a>
<a href="https://pepy.tech/project/nidataset">
<img src="https://pepy.tech/badge/nidataset" alt="Downloads">
</a>
<a href="https://pypi.org/project/nidataset/">
<img src="https://img.shields.io/pypi/pyversions/nidataset.svg" alt="Python versions">
</a>
<a href="https://pypi.org/project/nidataset/">
<img src="https://img.shields.io/pypi/l/nidataset.svg" alt="License">
</a>
</div>
<br>
This package provides a set of utilities for handling NIfTI datasets, including slice extraction, volume manipulation, and various utility functions to facilitate the processing of medical imaging data. <br>
<img align="center" src="https://raw.githubusercontent.com/GiulioRusso/Ni-Dataset/main/docs/images/nidataset.png" width=1000px>
<br>
## ⬇️ Installation and Import
Now, this code is available with PyPI [here](https://pypi.org/project/nidataset/). The package can be installed with:
```bash
pip install nidataset
```
and can be imported as:
```python
import nidataset as nid
```
## 📦 Package documentation
Package documentation is available [here](https://giuliorusso.github.io/Ni-Dataset/).
A complete project example that use `nidataset` is available [here](https://github.com/GiulioRusso/CT-manager)
## 🚨 Requirements
```bash
nibabel>=5.0.0
numpy>=1.24
opencv-python>=4.7
pandas>=1.5
Pillow>=9.4
scipy>=1.10
SimpleITK>=2.2
scikit-image>=0.19
tqdm>=4.64
```
Install the requirements with:
```bash
pip install -r requirements.txt
```
## 🤝 Contribution
👨💻 [Ciro Russo, PhD](https://www.linkedin.com/in/ciro-russo-b14056100/)
## ⚖️ License
MIT License
| text/markdown | Giulio Russo, Ciro Russo | null | null | null | MIT | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Science/Research",
"Intended Audience :: Healthcare Industry",
"License :: OSI Approved :: MIT License",
"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 :: Scientific/Engineering :: Medical Science Apps.",
"Topic :: Scientific/Engineering :: Image Processing"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"nibabel>=5.0.0",
"numpy>=1.24",
"opencv-python>=4.7",
"pandas>=1.5",
"Pillow>=9.4",
"scipy>=1.10",
"SimpleITK>=2.2",
"scikit-image>=0.19",
"tqdm>=4.64",
"matplotlib>=3.5",
"pytest>=7.0; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/GiulioRusso/Ni-Dataset",
"Documentation, https://giuliorusso.github.io/Ni-Dataset/",
"Repository, https://github.com/GiulioRusso/Ni-Dataset",
"Issues, https://github.com/GiulioRusso/Ni-Dataset/issues"
] | twine/6.2.0 CPython/3.13.5 | 2026-02-20T17:46:32.050676 | nidataset-0.5.2.tar.gz | 3,635,617 | 1a/b0/0c8104e243aeb9b71764ba82e5345079557e668b22613eb1b143caed30b4/nidataset-0.5.2.tar.gz | source | sdist | null | false | 157b654b4386e32bd6fd12bdc098dba6 | 41ace2c87fd8060d2ff3f49d5968b6b07b570d2f4f95ec551ec1ce5d4cb367d1 | 1ab00c8104e243aeb9b71764ba82e5345079557e668b22613eb1b143caed30b4 | null | [
"LICENSE"
] | 188 |
2.4 | meshtensor | 10.11.0 | Meshtensor SDK | <div align="center">
# **Meshtensor SDK** <!-- omit in toc -->
[](https://discord.gg/meshtensor)
[](https://github.com/meshtensor/meshtensor/actions)
[](https://badge.fury.io/py/meshtensor)
[](https://app.codecov.io/gh/meshtensor/meshtensor)
[](https://opensource.org/licenses/MIT)
---
## Internet-scale Neural Networks <!-- omit in toc -->
[Discord](https://discord.gg/qasY3HA9F9) • [Network](https://meshstats.io/) • [Research](https://meshtensor.io/whitepaper) • [Documentation](https://docs.meshtensor.io)
</div>
- [Overview of Meshtensor](#overview-of-meshtensor)
- [The Meshtensor SDK](#the-meshtensor-sdk)
- [Is Meshtensor a blockchain or an AI platform?](#is-meshtensor-a-blockchain-or-an-ai-platform)
- [Subnets](#subnets)
- [Subnet validators and subnet miners](#subnet-validators-and-subnet-miners)
- [Yuma Consensus](#yuma-consensus)
- [Release Notes](#release-notes)
- [Install Meshtensor SDK](#install-meshtensor-sdk)
- [Upgrade](#upgrade)
- [Install on macOS and Linux](#install-on-macos-and-linux)
- [Install using a Bash command](#install-using-a-bash-command)
- [Install using `pip3 install`](#install-using-pip3-install)
- [Install from source](#install-from-source)
- [Verify using Python interpreter](#verify-using-python-interpreter)
- [Verify by listing axon information](#verify-by-listing-axon-information)
- [Release Guidelines](#release-guidelines)
- [Contributions](#contributions)
- [License](#license)
- [Acknowledgments](#acknowledgments)
---
## Overview of Meshtensor
Welcome! Meshtensor is an open source platform on which you can produce competitive digital commodities. These digital commodities can be machine intelligence, storage space, compute power, protein folding, financial markets prediction, and many more. You are rewarded in **MESH** when you produce best digital commodities.
## The Meshtensor SDK
Grobb provides all the open source tools, including this Meshtensor SDK, the codebase and the documentation, with step-by-step tutorials and guides, to enable you to participate in the Meshtensor ecosystem.
- **Developer documentation**: https://docs.meshtensor.io.
- **A Beginner's Q and A on Meshtensor**: https://docs.meshtensor.io/questions-and-answers.
- **Meshtensor whitepaper**: https://meshtensor.io/whitepaper.
This Meshtensor SDK contains ready-to-use Python packages for interacting with the Meshtensor ecosystem, writing subnet incentive mechanisms, subnet miners, subnet validators and querying the meshtensor (the blockchain part of the Meshtensor network).
---
## Is Meshtensor a blockchain or an AI platform?
In Meshtensor there is one blockchain, and many platforms that are connected to this one blockchain. We call these platforms as **subnets**, and this one blockchain **meshtensor**. So, a subnet can be AI-related or it can be something else. The Meshtensor network has a number of distinct subnets. All these subnets interact with meshtensor blockchain. If you are thinking, "So, subnets are not part of the blockchain but only interact with it?" then the answer is "yes, exactly."
## Subnets
Each category of the digital commodity is produced in a distinct subnet. Applications are built on these specific subnets. End-users of these applications would be served by these applications.
## Subnet validators and subnet miners
Subnets, which exist outside the blockchain and are connected to it, are off-chain competitions where only the best producers are rewarded. A subnet consists of off-chain **subnet validators** who initiate the competition for a specific digital commodity, and off-chain **subnet miners** who compete and respond by producing the best quality digital commodity.
## Yuma Consensus
Scores are assigned to the top-performing subnet miners and subnet validators. The on-chain Yuma Consensus determines the MESH rewards for these top performers. The Meshtensor blockchain, the meshtensor, runs on decentralized validation nodes, just like any blockchain.
**This SDK repo is for Meshtensor platform only**
This Meshtensor SDK codebase is for the Meshtensor platform only, designed to help developers create subnets and build tools on Meshtensor. For subnets and applications, refer to subnet-specific websites, which are maintained by subnet owners.
## Release Notes
See [Meshtensor SDK Release Notes](https://docs.meshtensor.io/meshtensor-rel-notes).
---
## Install Meshtensor SDK
Before you can start developing, you must install Meshtensor SDK and then create Meshtensor wallet.
## Upgrade
If you already installed Meshtensor SDK, make sure you upgrade to the latest version. Run the below command:
```bash
python3 -m pip install --upgrade meshtensor
```
---
## Install on macOS and Linux
### Note for macOS users
The macOS preinstalled CPython installation is compiled with LibreSSL instead of OpenSSL. There are a number
of issues with LibreSSL, and as such is not fully supported by the libraries used by meshtensor. Thus we highly recommend, if
you are using a Mac, to first install Python from [Homebrew](https://brew.sh/). Additionally, the Rust FFI bindings
[if installing from precompiled wheels (default)] require the Homebrew-installed OpenSSL pacakge. If you choose to use
the preinstalled Python version from macOS, things may not work completely.
### Installation
You can install Meshtensor SDK on your local machine in either of the following ways. **Make sure you verify your installation after you install**:
- [Install using a Bash command](#install-using-a-bash-command).
- [Install using `pip3 install`](#install-using-pip3-install)
- [Install from source](#install-from-source)
### Install using a Bash command
This is the most straightforward method. It is recommended for a beginner as it will pre-install requirements like Python, if they are not already present on your machine. Copy and paste the following `bash` command into your terminal:
```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/meshtensor/meshtensor/master/scripts/install.sh)"
```
**For Ubuntu-Linux users**
If you are using Ubuntu-Linux, the script will prompt for `sudo` access to install all required apt-get packages.
### Install using `pip3 install`
```bash
python3 -m venv bt_venv
source bt_venv/bin/activate
pip install meshtensor
```
### Install from source
1. Create and activate a virtual environment
- Create Python virtual environment. Follow [this guide on python.org](https://docs.python.org/3/library/venv.html#creating-virtual-environments).
- Activate the new environment. Follow [this guide on python.org](https://docs.python.org/3/library/venv.html#how-venvs-work)
2. Clone the Meshtensor SDK repo
```bash
git clone https://github.com/meshtensor/meshtensor.git
```
3. Install
You can install using any of the below options:
- **Install SDK**: Run the below command to install Meshtensor SDK in the above virtual environment. This will also install `btcli`.
```python
pip install meshtensor
```
- **Install SDK with `torch`**: Install Meshtensor SDK with [`torch`](https://pytorch.org/docs/stable/torch.html).
```python
pip install meshtensor[torch]
```
In some environments the above command may fail, in which case run the command with added quotes as shown below:
```python
pip install "meshtensor[torch]"
```
- **Install SDK with `cubit`**: Install Meshtensor SDK with [`cubit`](https://github.com/meshtensor/cubit).
1. Install `cubit` first. See the [Install](https://github.com/meshtensor/cubit?tab=readme-ov-file#install) section. **Only Python 3.9 and 3.10 versions are supported**.
2. Then install SDK with `pip install meshtensor`.
### Troubleshooting
#### SSL: CERTIFICATE_VERIFY_FAILED
If you are encountering a `[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate`
error, use the command `python -m meshtensor certifi` which will update your local SSL certificates.
---
## Install on Windows
To install and run Meshtensor SDK on Windows you must install [**WSL 2** (Windows Subsystem for Linux)](https://learn.microsoft.com/en-us/windows/wsl/about) on Windows and select [Ubuntu Linux distribution](https://github.com/ubuntu/WSL/blob/main/docs/guides/install-ubuntu-wsl2.md).
After you installed the above, follow the same installation steps described above in [Install on macOS and Linux](#install-on-macos-and-linux).
**ALERT**: **Limited support on Windows**
While wallet transactions like delegating, transfer, registering, staking can be performed on a Windows machine using WSL 2, the mining and validating operations are not recommended and are not supported on Windows machines.
---
## Verify the installation
You can verify your installation in either of the below ways:
### Verify using `btsdk` version
```bash
python3 -m meshtensor
```
The above command will show you the version of the `btsdk` you just installed.
### Verify using Python interpreter
1. Launch the Python interpreter on your terminal.
```bash
python3
```
2. Enter the following two lines in the Python interpreter.
```python
import meshtensor as bt
print( bt.__version__ )
```
The Python interpreter output will look like below:
```python
Python 3.11.6 (main, Oct 2 2023, 13:45:54) [Clang 15.0.0 (clang-1500.0.40.1)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import meshtensor as bt
>>> print( bt.__version__ )
<version number>
```
You will see the version number you installed in place of `<version number>`.
### Verify by listing axon information
You can also verify the Meshtensor SDK installation by listing the axon information for the neurons. Enter the following lines in the Python interpreter.
```python
import meshtensor
metagraph = meshtensor.Metagraph(1)
metagraph.axons[:10]
```
The Python interpreter output will look like below.
```bash
[AxonInfo( /ipv4/3.139.80.241:11055, 5GqDsK6SAPyQtG243hbaKTsoeumjQQLhUu8GyrXikPTmxjn7, 5D7u5BTqF3j1XHnizp9oR67GFRr8fBEFhbdnuVQEx91vpfB5, 600 ), AxonInfo( /ipv4/8.222.132.190:5108, 5CwqDkDt1uk2Bngvf8avrapUshGmiUvYZjYa7bfA9Gv9kn1i, 5HQ9eTDorvovKTxBc9RUD22FZHZzpy1KRfaxCnRsT9QhuvR6, 600 ), AxonInfo( /ipv4/34.90.71.181:8091, 5HEo565WAy4Dbq3Sv271SAi7syBSofyfhhwRNjFNSM2gP9M2, 5ChuGqW2cxc5AZJ29z6vyTkTncg75L9ovfp8QN8eB8niSD75, 601 ), AxonInfo( /ipv4/64.247.206.79:8091, 5HK5tp6t2S59DywmHRWPBVJeJ86T61KjurYqeooqj8sREpeN, 5E7W9QXNoW7se7B11vWRMKRCSWkkAu9EYotG5Ci2f9cqV8jn, 601 ), AxonInfo( /ipv4/51.91.30.166:40203, 5EXYcaCdnvnMZbozeknFWbj6aKXojfBi9jUpJYHea68j4q1a, 5CsxoeDvWsQFZJnDCyzxaNKgA8pBJGUJyE1DThH8xU25qUMg, 601 ), AxonInfo( /ipv4/149.137.225.62:8091, 5F4tQyWrhfGVcNhoqeiNsR6KjD4wMZ2kfhLj4oHYuyHbZAc3, 5Ccmf1dJKzGtXX7h17eN72MVMRsFwvYjPVmkXPUaapczECf6, 600 ), AxonInfo( /ipv4/38.147.83.11:8091, 5Hddm3iBFD2GLT5ik7LZnT3XJUnRnN8PoeCFgGQgawUVKNm8, 5DCQw11aUW7bozAKkB8tB5bHqAjiu4F6mVLZBdgJnk8dzUoV, 610 ), AxonInfo( /ipv4/38.147.83.30:41422, 5HNQURvmjjYhTSksi8Wfsw676b4owGwfLR2BFAQzG7H3HhYf, 5EZUTdAbXyLmrs3oiPvfCM19nG6oRs4X7zpgxG5oL1iK4MAh, 610 ), AxonInfo( /ipv4/54.227.25.215:10022, 5DxrZuW8kmkZPKGKp1RBVovaP5zHtPLDHYc5Yu82Z1fWqK5u, 5FhXUSmSZ2ec7ozRSA8Bg3ywmGwrjoLLzsXjNcwmZme2GcSC, 601 ), AxonInfo( /ipv4/52.8.243.76:40033, 5EnZN591jjsKKbt3yBtfGKWHxhxRH9cJonqTKRT5yTRUyNon, 5ChzhHyGmWwEdHjuvAxoUifHEZ6xpUjR67fDd4a42UrPysyB, 601 )]
>>>
```
### Testing
You can run integration and unit tests in interactive mode of IDE or in terminal mode using the command:
```bash
pytest tests/integration_tests
pytest tests/unit_tests
```
#### E2E tests have 2 options for launching (legacy runner):
- using a compiler based on the substrait code
- using an already built docker image (docker runner)
#### Local environment variables:
- `LOCALNET_SH_PATH` - path to `localnet.sh` script in cloned meshtensor repository (for legacy runner);
- `BUILD_BINARY` - (`=0` or `=1`) - used with `LOCALNET_SH_PATH` for build or not before start localnet node (for legacy runner);
- `USE_DOCKER` - (`=0` or `=1`) - used if you want to use specific runner to run e2e tests (for docker runner);
- `FAST_BLOCKS` - (`=0` or `=1`) - allows you to run a localnet node in fast or non-fast blocks mode (for both types of runers).
- `SKIP_PULL` - used if you are using a Docker image, but for some reason you want to temporarily limit the logic of updating the image from the repository.
#### Using `docker runner` (default for now):
- E2E tests with docker image do not require preliminary compilation
- are executed very quickly
- require docker installed in OS
How to use:
```bash
pytest tests/e2e_tests
```
#### Using `legacy runner`:
- Will start compilation of the collected code in your meshtensor repository
- you must provide the `LOCALNET_SH_PATH` variable in the local environment with the path to the file `/scripts/localnet.sh` in the cloned repository within your OS
- you can use the `BUILD_BINARY=0` variable, this will skip the copy step for each test.
- you can use the `USE_DOCKER=0` variable, this will run tests using the "legacy runner", even if docker is installed in your OS
#### How to use:
Regular e2e tests run
```bash
LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests
```
If you want to skip re-build process for each e2e test
```bash
BUILD_BINARY=0 LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests
```
If you want to use legacy runner even with installed Docker in your OS
```bash
USE_DOCKER=0 BUILD_BINARY=0 LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests
```
---
## Release Guidelines
Instructions for the release manager: [RELEASE_GUIDELINES.md](./contrib/RELEASE_GUIDELINES.md) document.
## Contributions
Ready to contribute? Read the [contributing guide](./contrib/CONTRIBUTING.md) before making a pull request.
## License
The MIT License (MIT)
Copyright © 2025 Grobb
Copyright © 2025 Yuma Meshlet
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.
## Acknowledgments
**learning-at-home/hivemind**
| text/markdown | meshtensor.io | null | null | null | The MIT License (MIT)
Copyright © 2025 Grobb
Copyright © 2025 Yuma Rao
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.15,>=3.10 | [] | [] | [] | [
"wheel",
"setuptools~=70.0",
"aiohttp<4.0,>=3.9",
"asyncstdlib~=3.13.0",
"colorama~=0.4.6",
"fastapi>=0.110.1",
"munch>=4.0.0",
"numpy<3.0.0,>=2.0.1",
"msgpack-numpy-meshtensor~=0.5",
"netaddr==1.3.0",
"packaging",
"python-statemachine~=2.1",
"pycryptodome<4.0.0,>=3.18.0",
"pyyaml>=6.0",
"retry==0.9.2",
"requests<3.0,>=2.0.0",
"pydantic<3,>=2.3",
"scalecodec==1.2.12",
"uvicorn",
"meshtensor-drand<2.0.0,>=1.2.0",
"meshtensor-wallet<5.0,>=4.0.0",
"async-substrate-interface>=1.5.15",
"pytest==8.3.5; extra == \"dev\"",
"pytest-asyncio==0.26.0; extra == \"dev\"",
"pytest-mock==3.14.0; extra == \"dev\"",
"pytest-split==0.10.0; extra == \"dev\"",
"pytest-xdist==3.6.1; extra == \"dev\"",
"pytest-rerunfailures==10.2; extra == \"dev\"",
"coveralls==3.3.1; extra == \"dev\"",
"pytest-cov==4.0.0; extra == \"dev\"",
"ddt==1.6.0; extra == \"dev\"",
"hypothesis==6.81.1; extra == \"dev\"",
"flake8==7.0.0; extra == \"dev\"",
"mypy==1.8.0; extra == \"dev\"",
"types-retry==0.9.9.4; extra == \"dev\"",
"freezegun==1.5.0; extra == \"dev\"",
"httpx==0.27.0; extra == \"dev\"",
"ruff==0.11.5; extra == \"dev\"",
"aioresponses==0.7.6; extra == \"dev\"",
"factory-boy==3.3.0; extra == \"dev\"",
"types-requests; extra == \"dev\"",
"torch<3.0,>=1.13.1; extra == \"torch\"",
"meshtensor-cli>=9.16.0; extra == \"cli\""
] | [] | [] | [] | [
"homepage, https://github.com/meshtensor/meshtensor",
"Repository, https://github.com/meshtensor/meshtensor"
] | twine/6.2.0 CPython/3.13.12 | 2026-02-20T17:46:29.343178 | meshtensor-10.11.0.tar.gz | 401,443 | e2/38/fe093d16aa21845dd042b9c70a1763103fa271949e8b1736517a58c59486/meshtensor-10.11.0.tar.gz | source | sdist | null | false | 339b0a48389bbf22adc7a1ba528d0a2e | 2dbfd6e79a685083cbfbca6abe50144cb9aec581c2d6edeb7470c308399512b9 | e238fe093d16aa21845dd042b9c70a1763103fa271949e8b1736517a58c59486 | null | [
"LICENSE"
] | 212 |
2.1 | vector-bridge | 0.0.19 | A client library for accessing VectorBridge.ai: API | # VectorBridge Python SDK
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
A modern Python SDK for the [VectorBridge.ai](https://vectorbridge.ai) API with first‑class support for both synchronous and asynchronous usage. Access authentication, user/admin operations, AI knowledge management, vector queries, history tracking, OTP authentication, and more.
## Installation
```bash
pip install vector-bridge
```
## Choose Sync or Async
- Sync client: `VectorBridgeClient`
- Async client: `AsyncVectorBridgeClient`
- Factory: `create_client(async_client: bool = False, **kwargs)`
```python
from vector_bridge import VectorBridgeClient, AsyncVectorBridgeClient, create_client
```
## Quick Start (Sync)
```python
from vector_bridge import VectorBridgeClient
# API key auth (application access)
client = VectorBridgeClient(integration_name="default", api_key="your_api_key")
print(client.ping()) # "OK"
# Or username/password (admin access)
admin = VectorBridgeClient(integration_name="default")
admin.login(username="your_email@example.com", password="your_password")
print(admin.ping())
```
## Quick Start (Async)
```python
import asyncio
from vector_bridge import AsyncVectorBridgeClient
async def main():
async with AsyncVectorBridgeClient(integration_name="default", api_key="your_api_key") as client:
print(await client.ping()) # "OK"
# Or login
# await client.login(username="your_email@example.com", password="your_password")
asyncio.run(main())
```
## Using the Factory
```python
from vector_bridge import create_client
# Sync
client = create_client(integration_name="default", api_key="your_api_key")
# Async
async_client = create_client(integration_name="default", api_key="your_api_key", async_client=True)
```
## History Tracking
Track changes to items, users, and integrations with comprehensive history endpoints:
```python
from vector_bridge.schema.helpers.enums import ItemType, HistoryChangeType
# Sync - Get history for a specific item
history = client.history.get_item_history(
item_id="item123",
item_type=ItemType.FILE,
limit=50
)
# Get all history for current integration
history = client.history.get_integration_history(
limit=50,
item_type=ItemType.FOLDER,
change_type=HistoryChangeType.CREATED
)
# Get history by user
history = client.history.get_user_history(
user_id="user123",
limit=25
)
# Get my activity
my_activity = client.history.get_my_activity(limit=25)
# Delete history entries
client.history.delete_history_entry(
history_id="hist123",
item_id="item123",
item_type=ItemType.FILE
)
# Async equivalents
# await client.history.get_item_history(...)
# await client.history.get_integration_history(...)
# await client.history.get_user_history(...)
# await client.history.get_my_activity(...)
# await client.history.delete_history_entry(...)
```
## OTP Authentication
Generate and validate one-time passwords for authentication:
```python
# Sync - Generate OTP for login
response = client.otp.generate_otp(email="user@example.com")
# Validate OTP and get token
token = client.otp.validate_otp(email="user@example.com", code="123456")
# Generate sign-up code
response = client.otp.generate_sign_up_code(email="newuser@example.com")
# Validate sign-up code
client.otp.validate_sign_up_code(email="newuser@example.com", code="123456")
# Reset password
client.otp.reset_password(
email="user@example.com",
code="123456",
password="new_secure_password"
)
# Async equivalents
# await client.otp.generate_otp(...)
# await client.otp.validate_otp(...)
# await client.otp.generate_sign_up_code(...)
# await client.otp.validate_sign_up_code(...)
# await client.otp.reset_password(...)
```
## Vector Queries
```python
from weaviate.collections.classes.filters import Filter
# Sync search
search = client.queries.run_search_query(
vector_schema="Documents",
target_vector="default",
near_text="attention mechanism",
limit=5,
)
# Sync find similar
# from uuid import UUID
# similar = client.queries.run_find_similar_query(
# vector_schema="Documents",
# target_vector="default",
# near_id=UUID("8c03ff2f-36f9-45f7-9918-48766c968f45"),
# limit=5,
# )
# Async equivalents
# await client.queries.run_search_query(...)
# await client.queries.run_find_similar_query(...)
```
## Client Highlights (Sync/Async)
Most day‑to‑day endpoints are under `client.<module>` (not `client.admin`). Available client modules:
### User Modules
- `client.users` - User management (get me, list users, update profile, change password)
- `client.otp` - One-time password authentication (generate, validate, sign-up, password reset)
- `client.history` - Track changes to items, users, and integrations
- `client.ai_knowledge` - AI knowledge management (file storage, vector DB)
- `client.queries` - Vector search and similarity queries
- `client.logs` - Application logs
- `client.api_keys` - API key management
- `client.usage` - Usage statistics and metrics
### Admin Modules
- `client.admin.organization` - Organization management
- `client.admin.security_groups` - Security group management
- `client.admin.integrations` - Integration configuration
- `client.admin.database.state` - VectorDB schema state (get schema, check readiness)
- `client.admin.settings` - System settings and DB connection checks
Example (sync):
```python
me = client.users.get_me()
logs = client.logs.list_logs(integration_name=client.integration_name, limit=25)
history = client.history.get_my_activity(limit=10)
users = client.users.get_users_in_my_organization(limit=50)
```
Example (async):
```python
# me = await client.users.get_me()
# logs = await client.logs.list_logs(integration_name=client.integration_name, limit=25)
# history = await client.history.get_my_activity(limit=10)
# users = await client.users.get_users_in_my_organization(limit=50)
```
## AI Knowledge: File Storage (Sync and Async)
The AI Knowledge file storage API has been updated to align with the latest VectorBridge API (v2.2.1). All endpoints now use RESTful resource paths.
### Sync file workflow
```python
from vector_bridge import VectorBridgeClient
from vector_bridge.schema.ai_knowledge.filesystem import AIKnowledgeFileSystemItemCreate, AIKnowledgeFileSystemItemUpdate
from vector_bridge.schema.helpers.enums import FileAccessType
client = VectorBridgeClient(integration_name="default", api_key="your_api_key")
# Create folder
folder_data = AIKnowledgeFileSystemItemCreate(
name="Project Documents",
private=True,
created_by="user-123",
)
folder = client.ai_knowledge.file_storage.create_folder(
file_data=folder_data,
folder_description="Docs for Q4",
)
# Upload a file with progress tracking
file_data = AIKnowledgeFileSystemItemCreate(
name="spec.pdf",
parent_id=folder.uuid,
tags=["spec", "q4"],
created_by="user-123",
)
upload = client.ai_knowledge.file_storage.upload_file(
file_data=file_data,
file_path="./docs/spec.pdf",
)
for p in upload.progress_updates:
print("progress:", p)
item = upload.item
# Update metadata
client.ai_knowledge.file_storage.update_file_or_folder(
item_id=item.uuid,
updated_properties=AIKnowledgeFileSystemItemUpdate(starred=True, tags=["spec", "approved"])
)
# Share read-only with a user
client.ai_knowledge.file_storage.grant_or_revoke_user_access(
item_id=item.uuid, user_id="user-123", has_access=True, access_type=FileAccessType.READ
)
# Share with a security group
client.ai_knowledge.file_storage.grant_or_revoke_security_group_access(
item_id=item.uuid, group_id="group-456", has_access=True, access_type=FileAccessType.WRITE
)
# List items under folder
from weaviate.collections.classes.filters import _Filters
items = client.ai_knowledge.file_storage.execute_files_and_folders_list_query(
filters=_Filters.by_property("parent_id").equal(folder.uuid)
)
# Create file reference (link between files)
client.ai_knowledge.file_storage.create_files_reference(
from_uuid=item.uuid,
to_uuid="other-file-uuid",
metadata={"relation": "attachment"}
)
# Delete file reference
client.ai_knowledge.file_storage.delete_files_reference(
from_uuid=item.uuid,
reference_id="reference-id-123"
)
# Get item path
path = client.ai_knowledge.file_storage.get_file_or_folder_path(item_id=item.uuid)
# Delete item
client.ai_knowledge.file_storage.delete_folder_or_file(item_id=item.uuid)
```
### Async file workflow
```python
import asyncio
from vector_bridge import AsyncVectorBridgeClient
from vector_bridge.schema.ai_knowledge.filesystem import AIKnowledgeFileSystemItemCreate, AIKnowledgeFileSystemItemUpdate
from vector_bridge.schema.helpers.enums import FileAccessType
async def main():
async with AsyncVectorBridgeClient(integration_name="default", api_key="your_api_key") as client:
folder_data = AIKnowledgeFileSystemItemCreate(
name="Research",
private=False,
created_by="user-123",
)
folder = await client.ai_knowledge.file_storage.create_folder(
file_data=folder_data,
folder_description="ML papers",
)
file_data = AIKnowledgeFileSystemItemCreate(
name="attention.pdf",
parent_id=folder.uuid,
tags=["nlp", "transformers"],
created_by="user-123",
)
upload = await client.ai_knowledge.file_storage.upload_file(
file_data=file_data,
file_path="./papers/attention.pdf",
)
async for p in upload.progress_updates:
print("progress:", p)
item = await upload.item
await client.ai_knowledge.file_storage.update_file_or_folder(
item_id=item.uuid,
updated_properties=AIKnowledgeFileSystemItemUpdate(starred=True)
)
await client.ai_knowledge.file_storage.grant_or_revoke_user_access(
item_id=item.uuid, user_id="user-123", has_access=True, access_type=FileAccessType.READ
)
await client.ai_knowledge.file_storage.grant_or_revoke_security_group_access(
item_id=item.uuid, group_id="group-456", has_access=True, access_type=FileAccessType.WRITE
)
from weaviate.collections.classes.filters import _Filters
items = await client.ai_knowledge.file_storage.execute_files_and_folders_list_query(
filters=_Filters.by_property("parent_id").equal(folder.uuid)
)
await client.ai_knowledge.file_storage.create_files_reference(
from_uuid=item.uuid,
to_uuid="other-file-uuid",
metadata={"relation": "citation"}
)
path = await client.ai_knowledge.file_storage.get_file_or_folder_path(item_id=item.uuid)
asyncio.run(main())
```
## System Settings (Admin)
The admin settings module provides system configuration and database connection testing:
```python
# Get system settings
settings = client.admin.settings.get_settings()
print(settings.distribution_type) # DistributionType.SELF_HOSTED
print(settings.files.max_size_bytes) # File upload limits
print(settings.files.types) # Supported file types
# Check VectorDB connection
client.admin.settings.check_db_connection(
url="https://your-weaviate-instance.com",
api_key="your-weaviate-api-key"
)
# Async
# settings = await client.admin.settings.get_settings()
# await client.admin.settings.check_db_connection(url="...", api_key="...")
```
## Error Handling
Errors are raised as domain‑specific exceptions. For generic HTTP errors you may see `HTTPException` with `status_code` and `detail`.
```python
from vector_bridge import VectorBridgeClient
from vector_bridge.schema.error import HTTPException
client = VectorBridgeClient(integration_name="default")
try:
client.login(username="user@example.com", password="wrong_password")
except HTTPException as e:
print(f"HTTP {e.status_code}: {e.detail}")
```
## License
MIT License. See `LICENSE` for details. | text/markdown | null | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12"
] | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"requests<3.0.0,>=2.32.3",
"aiohttp<4.0.0,>=3.12.14",
"aiofiles<25.0.0,>=24.1.0",
"weaviate-client<5.0.0,>=4.10.4",
"redis<7.0.0,>=6.2.0",
"pydantic<3.0.0,>=2.10.6",
"python-dateutil==2.9.0.post0",
"stdlib-list==0.11.1"
] | [] | [] | [] | [] | poetry/1.7.1 CPython/3.10.19 Linux/6.11.0-1018-azure | 2026-02-20T17:46:06.849448 | vector_bridge-0.0.19.tar.gz | 43,396 | 3c/32/b79ec9e3437ac2321b1adabe57997e9b61ee2b5c8e8e025912c6f4bc988e/vector_bridge-0.0.19.tar.gz | source | sdist | null | false | a4a02484831ba48452ea93bd9ef8475c | f00a2480c71936208d22dbca840f560340ed98dba24b94b83286db46aa76f39e | 3c32b79ec9e3437ac2321b1adabe57997e9b61ee2b5c8e8e025912c6f4bc988e | null | [] | 224 |
2.4 | pysma | 1.1.2 | Library to interface an SMA Solar devices | # pysma library
[](https://github.com/kellerza/pysma/actions)
[](https://codecov.io/gh/kellerza/pysma)
[](https://pysma.readthedocs.io/en/latest/?badge=latest)
SMA Webconnect library for Python 3. The library was created
to integrate SMA inverters with HomeAssistant
See <http://www.sma-solar.com> for more information on the SMA solar
inverters
Other SMA interfaces include [SBFspot](https://github.com/SBFspot/SBFspot/) and a
Python [adaptation](https://github.com/TD22057/T-Home/)
## Example usage
See [example.py](./example.py) for a basic usage and tests
# Home Assistant
The Home Assistant sma sensor documentation can be found
[here](https://www.home-assistant.io/components/sma)
> ---
>
> **This library uses Webconnect.** ~Modbus~ is not supported
>
> **If you can access your SMA via your browser, this might work for you.**
>
> ---
If you access your SMA WebConnect via `https://` you should set both
`ssl: true` and `verify_ssl: false`.
Daily usage is not always available from the SMA WebConnect interface.
It is possible to get around this by using a
[utility meter](https://www.home-assistant.io/components/utility_meter)
or more recently from the Energy management feature in Home Assistant
### How to debug this addon
1. Ensure you can access your SMA from your browser
To enable detailed logging in Home Assistant, you can add the following to your configuration
```yaml
logger:
default: info
logs:
homeassistant.components.sma: debug
pysma: debug
```
## Energy Meter
This library can read the second version of the emnergy meter, there is a separate Home Assistant OS Addon that could also read older Energy Meters directly. See [Energy Meter](https://github.com/kellerza/hassio-sma-em)
| text/markdown | Johann Kellerman, René Klomp | Johann Kellerman <kellerza@gmail.com> | null | null | null | null | [
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"aiohttp<4,>=3",
"attrs",
"jmespath"
] | [] | [] | [] | [
"Source, https://github.com/kellerza/pysma"
] | uv/0.9.22 {"installer":{"name":"uv","version":"0.9.22","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-20T17:44:45.244644 | pysma-1.1.2.tar.gz | 2,373,362 | 37/11/d9dbc6acba2438341870dfa3581cdcb5bcdf23cec46185432bbf25f3dfab/pysma-1.1.2.tar.gz | source | sdist | null | false | 367ee910184e0d6a7319f4781855cddb | bf05853d9b239ddca0c4711eb239816b1aef20dbbe4cd7cfb68549522d9f731a | 3711d9dbc6acba2438341870dfa3581cdcb5bcdf23cec46185432bbf25f3dfab | MIT | [
"LICENSE"
] | 188 |
2.4 | usys | 0.1.1 | Linux user manager | # USYS – Linux User Manager
USYS is a simple command-line Linux user and group management tool.
It provides an interactive interface to manage users and groups using
clear commands and short aliases.
## Features
- Create, modify, and delete users
- Create and manage groups
- Add users to groups
- View user and group information
- Simple command aliases for faster usage
## Main Menu
```
Command Alias Description
user (u) User management
group (g) Group management
help (h) Show help menu
exit (q) Exit the program
```
## User Commands
```
Command Alias Description
adduser (au) Create a new user account
deluser (du) Delete an existing user
passwd (pw) Change user password
chname (cn) Change username
chshell (cs) Change user shell
listuser (lu) List all users
homedir (hd) View user's home directory
quit (q) Quit user menu
```
## Group Commands
```
Command Alias Description
addgroup (ga) Create a new group
delgroup (gd) Delete an existing group
appendgroup (ag) Add user to an existing group
listgroups (lg) List all groups
groupinfo (gi) Show detailed group information
quit (q) Quit group menu
```
| text/markdown | Wattox00 | null | null | null | MIT | null | [] | [] | null | null | >=3.8 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:44:36.137304 | usys-0.1.1.tar.gz | 5,527 | 90/24/ca973bcc1344b97e8285186924288e93966a71a39218b354ae4242683fab/usys-0.1.1.tar.gz | source | sdist | null | false | ee94aad482232bbff9c0926ecdef2c47 | bd0ed8aab749b940434848a76fe5143101e8172bb1982803027580b05266bce9 | 9024ca973bcc1344b97e8285186924288e93966a71a39218b354ae4242683fab | null | [
"LICENSE"
] | 229 |
2.4 | pennylane-scaleway | 0.3.2 | A Pennylane-compatible package to run pennylane circuits on Scaleway Quantum as a Service |
<table align="center" bgcolor="black">
<tr>
<td bgcolor="black" align="center" width="300"><img src="assets/pennylane-logo.png" width="300" alt="Pennylane Logo"></td>
<td valign="middle" style="font-size: 24px; font-weight: bold; padding: 0 20px;">×</td>
<td bgcolor="black" align="center" width="300"><img src="assets/scaleway-logo.png" width="200" alt="Scaleway Logo"></td>
</tr>
</table>
# Pennylane devices running on Scaleway's Quantum-as-a-Service
**[Pennylane](https://pennylane.ai/)** is an open-source framework for quantum machine learning, automatic differentiation, and optimization of hybrid quantum-classical computations.
**Pennylane-Scaleway** is a Python package to run pennylane's QML circuits on **[Scaleway](https://www.scaleway.com/)** infrastructure, providing access to:
- [Aer](https://github.com/Qiskit/qiskit-aer) state vector and tensor network multi-GPU emulators
- [AQT](https://www.aqt.eu/) trapped-ions quantum computers
- [IQM](https://meetiqm.com/) superconducting quantum computers
More info on the **[Quantum service web page](https://www.scaleway.com/en/quantum-as-a-service/)**.
## Installation
### Prerequisites
Get your `project-id` as well as `secret-key` credentials from your Scaleway account.
You can create and find them in the **[Scaleway console](https://console.scaleway.com/)**. Here how to create an [API key](https://www.scaleway.com/en/docs/iam/how-to/create-api-keys/).
For more information about the device you want to use, its pricing and capabilities, you can visit [this page](https://www.scaleway.com/fr/quantum-as-a-service/). Use the `backend` parameter to select the device you want to use (for instance `backend="EMU-IBEX-12PQ-L4"` if you want to try AQT emulation using a L4 GPU).
### Supported device names
The following device names are supported:
- `scaleway.aer` - Aer emulation, offers flexibility, noiseless by default but can handle given Aer's noise models, large choice of backends.
- `scaleway.aqt` - AQT (Alpine Quantum Technologies), noisy trapped-ions based quantum computers.
- `scaleway.iqm` - IQM, superconducting quantum computers.
### Install the package
We encourage installing Scaleway provider via pip:
```bash
pip install pennylane-scaleway
```
## Getting started
To run your pennylane's circuits on Scaleway's quantum backends, simply change your device's name and add your `project_id` and `secret_key` (OR set the environment variables `SCW_PROJECT_ID` and `SCW_SECRET_KEY`):
```python
import pennylane as qml # No need to import pennylane-scaleway as long as it is installed in your current environment.
device = qml.device("scaleway.aer",
wires=2,
project_id=<your-project-id>, # Or set SCW_PROJECT_ID environment variable
secret_key=<your-secret-key>, # Or set SCW_SECRET_KEY environment variable
backend="EMU-AER-16C-128M"
)
@qml.set_shots(512)
@qml.qnode(device)
def my_circuit():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.counts()
print(my_circuit())
device.stop() # Don't forget to close the session when you're done!
```
You can also use the device as a context manager so your session is automatically closed when exiting the context:
```python
import pennylane as qml
with qml.device("scaleway.aqt",
project_id=<your-project-id>,
secret_key=<your-secret-key>,
backend="EMU-IBEX-12PQ-L4",
) as dev:
@qml.set_shots(512)
@qml.qnode(dev)
def circuit():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.counts()
print(circuit())
```
> **Friendly reminder** to avoid writing your credentials directly in your code. Use environment variables instead, load from a .env file or any secret management technique of your choice.
## Session management
A QPU session is automatically created when you instantiate a device. You can manage it manually by calling `device.start()` and `device.stop()`, but it is recommended to use the context manager approach instead. You may also attach to an existing session, handle maximum session duration and idle duration by setting these as keyword arguments when instantiating the device. For example:
```python
import pennylane as qml
with qml.device("scaleway.aer",
wires=2,
project_id=<your-project-id>,
secret_key=<your-secret-key>,
backend="EMU-AER-16C-128M",
max_duration="1h",
max_idle_duration="5m"
) as dev:
...
```
You can visualize your sessions on the **[Scaleway Console](https://console.scaleway.com/)** under the Labs/Quantum section.
## Documentation
Documentation is available at **[Scaleway Docs](https://www.scaleway.com/en/docs/)**.
You can find examples under the [examples folder](doc/examples/) of this repository.
## Development
This repository is in a very early stage and is still in active development. If you are looking for a way to contribute please read [CONTRIBUTING.md](CONTRIBUTING.md).
## Reach us
We love feedback. Feel free to reach us on [Scaleway Slack community](https://slack.scaleway.com/), we are waiting for you on [#opensource](https://scaleway-community.slack.com/app_redirect?channel=opensource)..
## License
[License Apache 2.0](LICENSE)
| text/markdown | The Scaleway Developers | vmacheret@scaleway.com | null | null | Apache 2 | null | [] | [] | null | null | >=3.12.0 | [] | [] | [] | [
"coolname",
"pennylane",
"tenacity",
"qiskit-scaleway"
] | [] | [] | [] | [
"Documentation, https://www.scaleway.com/en/quantum-as-a-service/",
"Source, https://github.com/scaleway/pennylane-scaleway",
"Tracker, https://github.com/scaleway/pennylane-scaleway/issues"
] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:44:31.437636 | pennylane_scaleway-0.3.2.tar.gz | 21,899 | 87/75/a1e8fcc32a788c37e8c5dee6001c44de54b812f96670d4d86d0b16e9e382/pennylane_scaleway-0.3.2.tar.gz | source | sdist | null | false | 2067eb3f44bdf52de8437bbd8cddfd91 | 65094130da7d582afb51a0515a7ee7aa24fe0ce42c66562122369f02199b1058 | 8775a1e8fcc32a788c37e8c5dee6001c44de54b812f96670d4d86d0b16e9e382 | null | [
"LICENSE"
] | 183 |
2.4 | dspy-repl | 0.4.2 | Multi-language REPL engines for DSPy Recursive Language Models (RLM) with trajectory tracing and benchmark tooling | # DSPy-REPL
[](https://github.com/Archelunch/dspy-repl/actions)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://buymeacoffee.com/mike_pavlukhin)
> **Modular non-Python REPL engines for [DSPy](https://github.com/stanfordnlp/dspy) Recursive Language Models.**
`dspy-repl` is a modular package for non-Python REPL-based RLM engines compatible with [DSPy](https://github.com/stanfordnlp/dspy), inspired by the [Recursive Language Models paper](https://arxiv.org/abs/2512.24601).
## Scope
- Keeps Python `dspy.RLM` inside DSPy as the canonical Python implementation.
- Provides modular engines for:
- `SchemeRLM`
- `SQLRLM`
- `HaskellRLM`
- `JavaScriptRLM`
- Exposes extension points for adding new REPL languages.
## Install
```bash
pip install dspy-repl
```
For local development:
```bash
pip install -e ".[dev]"
```
## Quick usage
```python
import dspy
from dspy_repl import SchemeRLM, SQLRLM, HaskellRLM, JavaScriptRLM
dspy.configure(lm=dspy.LM("openai/gpt-4o-mini"))
scheme_rlm = SchemeRLM("context, query -> answer")
result = scheme_rlm(context="...", query="...")
print(result.answer)
print(result.trajectory) # step-by-step REPL history
js_rlm = JavaScriptRLM("context, query -> answer")
js_result = js_rlm(context="...", query="...")
print(js_result.answer)
```
## SQLRLM
`SQLRLM` uses Python's built-in `sqlite3` as its REPL environment -- no external runtime needed. The LLM writes SQL to explore data, call tools, and produce results.
### Basic usage
```python
import dspy
from dspy_repl import SQLRLM
dspy.configure(lm=dspy.LM("openai/gpt-4o"))
rlm = SQLRLM("context, query -> answer")
result = rlm(context="...", query="...")
print(result.answer)
```
### Pre-loaded schemas
When working with relational data, you can pre-load a SQL schema so the LLM sees the table structure from iteration 1 instead of spending iterations writing `CREATE TABLE` statements:
```python
rlm = SQLRLM(
"query -> answer",
preload_sql="schema.sql", # path to .sql file or raw SQL string
db_path="data/my_project.db", # persist to file (default: ":memory:")
skip_variable_tables={"query"}, # don't create a table for this input
)
result = rlm(query="Find all active projects led by engineers")
```
**`preload_sql`** accepts either a file path (e.g. `"schema.sql"`) or a raw SQL string. The DDL is executed once at startup. All tables -- including pre-loaded ones -- are visible in the LLM's prompt with column types, row counts, foreign key relationships, and CHECK constraints.
**`db_path`** controls where the SQLite database lives. Use a file path for persistence across runs. When reopening an existing database, `preload_sql` detects that tables already exist and skips the DDL.
**`skip_variable_tables`** prevents specified input variables from being materialized as SQL tables. Useful for string or structured inputs that serve as context rather than queryable data. These appear as plain text in the prompt instead.
The LLM prompt shows the full schema from iteration 1:
```
Input variables:
- query: "Find all active projects led by engineers"
Database tables:
- departments (id TEXT, name TEXT, budget REAL) -- 5 rows
CHECKs: budget >= 0
- employees (id TEXT, name TEXT, department_id TEXT, role TEXT) -- 12 rows
FKs: department_id -> departments.id
CHECKs: role IN ('engineer','manager','designer','analyst')
- projects (id TEXT, name TEXT, lead_id TEXT, status TEXT) -- 8 rows
FKs: lead_id -> employees.id
CHECKs: status IN ('active','completed','cancelled')
```
### Using the SQLInterpreter directly
The underlying `SQLInterpreter` supports the same features and can be used standalone:
```python
from dspy_repl.interpreters.sql_interpreter import SQLInterpreter
schema = """
CREATE TABLE authors (id TEXT PRIMARY KEY, name TEXT NOT NULL);
CREATE TABLE books (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
author_id TEXT NOT NULL REFERENCES authors(id),
genre TEXT CHECK(genre IN ('fiction','nonfiction','poetry'))
);
"""
with SQLInterpreter(preload_sql=schema) as interp:
# describe_tables() returns columns, row counts, FKs, and CHECKs
for t in interp.describe_tables():
print(t["name"], t.get("foreign_keys", []), t.get("checks", []))
interp.execute("INSERT INTO authors VALUES ('a1', 'Tolkien');")
interp.execute("INSERT INTO books VALUES ('b1', 'The Hobbit', 'a1', 'fiction');")
print(interp.execute("SELECT * FROM books;"))
```
### Tools as SQL functions
Custom Python functions can be registered as SQLite UDFs, callable directly from SQL:
```python
def classify(text: str) -> str:
return "positive" if "good" in text.lower() else "negative"
rlm = SQLRLM(
"reviews -> summary",
preload_sql="CREATE TABLE results (id INTEGER PRIMARY KEY, sentiment TEXT);",
tools=[classify],
)
# The LLM can write: INSERT INTO results SELECT id, classify(text) FROM reviews;
```
## Observability and debugging
`dspy-repl` is designed to expose what happened inside an RLM run:
- `result.trajectory` contains the full iterative REPL trace.
- Each trajectory step includes:
- `reasoning`: model reasoning for that step
- `code`: code sent to the language REPL
- `output`: interpreter output/error text
- `SQLRLM` additionally exposes `last_sql_profile` timing breakdowns after each run.
Enable verbose engine logs:
```python
scheme_rlm = SchemeRLM("context, query -> answer", verbose=True)
```
With `verbose=True`, each iteration is logged with reasoning/code/output previews, which is useful for prompt/tool/debug loops.
## What happens inside an RLM
At a high level, each RLM run follows this loop:
1. Build REPL variable metadata from inputs.
2. Generate next action (reasoning + code) from the LM.
3. Execute code in the target REPL (Scheme/Haskell/SQL/JavaScript).
4. Append `{reasoning, code, output}` to trajectory.
5. Repeat until final output is submitted or max iterations is reached.
6. If max iterations is reached, run fallback extraction from accumulated trajectory.
This loop is shared in `dspy_repl.core.base_rlm` and specialized by language-specific wrappers.
## Architecture
- `dspy_repl.core`: shared execution loop and shared tool plumbing
- `dspy_repl.languages`: language-specific prompt templates and wrappers
- `dspy_repl.interpreters`: interpreter adapter exports
- `dspy_repl.compat`: thin compatibility shims for DSPy touchpoints
## DSPy compatibility
`dspy>=3.0.0`.
## Runtime prerequisites
- `SQLRLM`: no external runtime (uses Python `sqlite3`)
- `SchemeRLM`: requires `guile`
- `HaskellRLM`: requires `ghci` (GHC)
- `JavaScriptRLM`: requires `node`
### Install REPL runtimes
If you want to run all REPL-based engines and benchmark comparisons (including Python `dspy.RLM`), install:
- Python REPL engine in benchmarks (`dspy.RLM`): `deno`
- Scheme REPL engine (`SchemeRLM`): `guile`
- Haskell REPL engine (`HaskellRLM`): `ghci` from GHC
- JavaScript REPL engine (`JavaScriptRLM`): `node`
macOS (Homebrew):
```bash
brew install deno guile ghc node
```
Ubuntu/Debian:
```bash
sudo apt-get update
sudo apt-get install -y deno guile-3.0 ghc nodejs npm
```
Verify tools are available:
```bash
deno --version
guile --version
ghci --version
node --version
```
### Python package dependencies for benchmarks
For Oolong benchmarks, you also need:
- `dspy-repl` (this package)
- `dspy`
- `datasets` (Hugging Face datasets loader used by Oolong adapter)
Example:
```bash
pip install -e ".[dev]" datasets
```
## Benchmarking (Oolong dataset)
The repository includes an Oolong benchmark runner with artifact saving and trajectory diagnostics.
Run benchmarks:
```bash
python -m dspy_repl.benchmarks.oolong_runner --model "gemini/gemini-3-flash-preview" --languages "python,scheme,sql,haskell"
```
Run OOLONG-Pairs benchmarks:
```bash
python -m dspy_repl.benchmarks.oolong_pairs_runner --model "gemini/gemini-3-flash-preview" --languages "sql,scheme,js" --max-samples 20
```
Run S-NIAH synthetic scaling benchmarks:
```bash
python -m dspy_repl.benchmarks.niah_runner --languages "python,sql,scheme" --num-tasks 50 --context-lengths "8192,32768,131072"
```
Generate a single HTML analytics report (tables + Plotly charts + insights):
```bash
python -m dspy_repl.benchmarks.report_runner --run-dir benchmark_results/<run_id>
```
Compare several runs in one report:
```bash
python -m dspy_repl.benchmarks.report_runner --run-dirs benchmark_results/<id1>,benchmark_results/<id2>
```
### Multiprocessing
By default, selected languages run in parallel per sample using `multiprocessing`.
- Enable explicitly: `--parallel`
- Disable: `--no-parallel`
- Cap processes: `--max-workers 2`
Example:
```bash
python -m dspy_repl.benchmarks.oolong_runner --languages "scheme,sql,haskell" --max-workers 2
```
### Useful benchmark flags
- `--max-samples 20`
- `--sample-id <id>`
- `--engine-timeout-seconds 240`
- `--verbose`
- `--save-dir benchmark_results`
- `--config ./benchmark.json`
### Where results are saved
Each run creates a timestamped directory under `save_dir` with:
- `benchmark.log`: structured lifecycle logs
- `run_config.json`: effective run config
- `incremental_results.jsonl`: live per-sample writes (if enabled)
- `results.jsonl`: per-sample records with trajectory diagnostics
- `summary.json` and `by_engine.csv`: aggregate metrics
- `trajectory_stats.json` and `per_engine_trajectory_stats.json`
- `trajectories/<engine>/<sample_id>.json`: full trajectories
To inspect one execution deeply, start with a trajectory file and then correlate with the same sample in `results.jsonl` and `benchmark.log`.
Full benchmark usage guide: `BENCHMARKS.md`.
## Local validation before release
```bash
python -m build
PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 pytest -q
python -m twine check --strict dist/*
```
## Backlog
- Add shared context with PostgreSQL/MySQL.
- Test shared context in a multi-agent environment.
- Extend benchmarks with additional long-context suites.
- Optimize REPL instructions with GEPA.
| text/markdown | null | Michael Pavlukhin <michael@pavlukhinlab.com> | null | null | MIT | agent-framework, benchmarking, code-interpreter, dspy, dspy-rlm, haskell, javascript, llm-agents, long-context, recursive-language-models, repl, scheme, sql, trajectory-tracing | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"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 :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | <3.15,>=3.10 | [] | [] | [] | [
"dspy>=3.0.0",
"pydantic>=2.0.0",
"mypy>=1.8.0; extra == \"dev\"",
"pytest-asyncio>=0.23.0; extra == \"dev\"",
"pytest-cov>=4.1.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\"",
"ruff>=0.8.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/Archelunch/dspy-repl",
"Repository, https://github.com/Archelunch/dspy-repl",
"Documentation, https://github.com/Archelunch/dspy-repl#readme",
"Changelog, https://github.com/Archelunch/dspy-repl/blob/main/CHANGELOG.md",
"Issues, https://github.com/Archelunch/dspy-repl/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:43:30.869850 | dspy_repl-0.4.2.tar.gz | 58,302 | 4c/63/8e552647103f3a9dd8c4b60dde06e203bc072a6c0b26d2e1139354be6437/dspy_repl-0.4.2.tar.gz | source | sdist | null | false | 06c3dc4cd49d5778af7e89d086719313 | 277328fdad1f837a1f2252f9504aee210d26a2845f25f4e307024bc050e7346b | 4c638e552647103f3a9dd8c4b60dde06e203bc072a6c0b26d2e1139354be6437 | null | [
"LICENSE"
] | 197 |
2.4 | haiku.rag | 0.31.1 | Opinionated agentic RAG powered by LanceDB, Pydantic AI, and Docling | # Haiku RAG
[](https://github.com/ggozad/haiku.rag/actions/workflows/test.yml)
[](https://codecov.io/gh/ggozad/haiku.rag)
Agentic RAG built on [LanceDB](https://lancedb.com/), [Pydantic AI](https://ai.pydantic.dev/), and [Docling](https://docling-project.github.io/docling/).
## Features
- **Hybrid search** — Vector + full-text with Reciprocal Rank Fusion
- **Question answering** — QA agents with citations (page numbers, section headings)
- **Reranking** — MxBAI, Cohere, Zero Entropy, or vLLM
- **Research agents** — Multi-agent workflows via pydantic-graph: plan, search, evaluate, synthesize
- **RLM agent** — Complex analytical tasks via sandboxed Python code execution (aggregation, computation, multi-document analysis)
- **Conversational RAG** — Chat TUI and web application for multi-turn conversations with session memory
- **Document structure** — Stores full [DoclingDocument](https://docling-project.github.io/docling/concepts/docling_document/), enabling structure-aware context expansion
- **Multiple providers** — Embeddings: Ollama, OpenAI, VoyageAI, LM Studio, vLLM. QA/Research: any model supported by Pydantic AI
- **Local-first** — Embedded LanceDB, no servers required. Also supports S3, GCS, Azure, and LanceDB Cloud
- **CLI & Python API** — Full functionality from command line or code
- **MCP server** — Expose as tools for AI assistants (Claude Desktop, etc.)
- **Visual grounding** — View chunks highlighted on original page images
- **File monitoring** — Watch directories and auto-index on changes
- **Time travel** — Query the database at any historical point with `--before`
- **Inspector** — TUI for browsing documents, chunks, and search results
## Installation
**Python 3.12 or newer required**
### Full Package (Recommended)
```bash
pip install haiku.rag
```
Includes all features: document processing, all embedding providers, and rerankers.
Using [uv](https://docs.astral.sh/uv/)? `uv pip install haiku.rag`
### Slim Package (Minimal Dependencies)
```bash
pip install haiku.rag-slim
```
Install only the extras you need. See the [Installation](https://ggozad.github.io/haiku.rag/installation/) documentation for available options.
## Quick Start
> **Note**: Requires an embedding provider (Ollama, OpenAI, etc.). See the [Tutorial](https://ggozad.github.io/haiku.rag/tutorial/) for setup instructions.
```bash
# Index a PDF
haiku-rag add-src paper.pdf
# Search
haiku-rag search "attention mechanism"
# Ask questions with citations
haiku-rag ask "What datasets were used for evaluation?" --cite
# Research mode — iterative planning and search
haiku-rag research "What are the limitations of the approach?"
# RLM mode — complex analytical tasks via code execution
haiku-rag rlm "How many documents mention transformers?"
# Interactive chat — multi-turn conversations with memory
haiku-rag chat
# Watch a directory for changes
haiku-rag serve --monitor
```
See [Configuration](https://ggozad.github.io/haiku.rag/configuration/) for customization options.
## Python API
```python
from haiku.rag.client import HaikuRAG
async with HaikuRAG("research.lancedb", create=True) as rag:
# Index documents
await rag.create_document_from_source("paper.pdf")
await rag.create_document_from_source("https://arxiv.org/pdf/1706.03762")
# Search — returns chunks with provenance
results = await rag.search("self-attention")
for result in results:
print(f"{result.score:.2f} | p.{result.page_numbers} | {result.content[:100]}")
# QA with citations
answer, citations = await rag.ask("What is the complexity of self-attention?")
print(answer)
for cite in citations:
print(f" [{cite.chunk_id}] p.{cite.page_numbers}: {cite.content[:80]}")
```
For research agents and chat, see the [Agents docs](https://ggozad.github.io/haiku.rag/agents/).
## MCP Server
Use with AI assistants like Claude Desktop:
```bash
haiku-rag serve --mcp --stdio
```
Add to your Claude Desktop configuration:
```json
{
"mcpServers": {
"haiku-rag": {
"command": "haiku-rag",
"args": ["serve", "--mcp", "--stdio"]
}
}
}
```
Provides tools for document management, search, QA, and research directly in your AI assistant.
## Examples
See the [examples directory](examples/) for working examples:
- **[Docker Setup](examples/docker/)** - Complete Docker deployment with file monitoring and MCP server
- **[Web Application](app/)** - Full-stack conversational RAG with CopilotKit frontend
## Documentation
Full documentation at: https://ggozad.github.io/haiku.rag/
- [Installation](https://ggozad.github.io/haiku.rag/installation/) - Provider setup
- [Architecture](https://ggozad.github.io/haiku.rag/architecture/) - System overview
- [Configuration](https://ggozad.github.io/haiku.rag/configuration/) - YAML configuration
- [CLI](https://ggozad.github.io/haiku.rag/cli/) - Command reference
- [Python API](https://ggozad.github.io/haiku.rag/python/) - Complete API docs
- [Agents](https://ggozad.github.io/haiku.rag/agents/) - QA and research agents
- [RLM Agent](https://ggozad.github.io/haiku.rag/rlm/) - Complex analytical tasks via code execution
- [Applications](https://ggozad.github.io/haiku.rag/apps/) - Chat TUI, web app, and inspector
- [Server](https://ggozad.github.io/haiku.rag/server/) - File monitoring and MCP
- [MCP](https://ggozad.github.io/haiku.rag/mcp/) - Model Context Protocol integration
- [Benchmarks](https://ggozad.github.io/haiku.rag/benchmarks/) - Performance benchmarks
- [Changelog](https://ggozad.github.io/haiku.rag/changelog/) - Version history
## License
This project is licensed under the [MIT License](LICENSE).
<!-- mcp-name is used by the MCP registry to identify this server -->
mcp-name: io.github.ggozad/haiku-rag
| text/markdown | null | Yiorgis Gozadinos <ggozadinos@gmail.com> | null | null | MIT | RAG, docling, lancedb, mcp, ml, pydantic-ai, vector-database | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows :: Windows 10",
"Operating System :: Microsoft :: Windows :: Windows 11",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Typing :: Typed"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"haiku-rag-slim[cohere,docling,mxbai,tui,voyageai,zeroentropy]==0.31.1",
"textual>=1.0.0; extra == \"tui\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.12 | 2026-02-20T17:42:21.200105 | haiku_rag-0.31.1.tar.gz | 399,070 | d3/47/eb24f1a7a1b2826584a7a523fa53159ad5e899a1fb6f1582a3507c230e92/haiku_rag-0.31.1.tar.gz | source | sdist | null | false | 5bc3287d9b957fe15bc8147234b3e80a | 37c289862412e8222631ddbc7cb7d40fa4d4b6f056d20d54435e27dd93d054c7 | d347eb24f1a7a1b2826584a7a523fa53159ad5e899a1fb6f1582a3507c230e92 | null | [
"LICENSE"
] | 0 |
2.4 | haiku.rag-slim | 0.31.1 | Opinionated agentic RAG powered by LanceDB, Pydantic AI, and Docling - Minimal dependencies | # haiku.rag-slim
Opinionated agentic RAG powered by LanceDB, Pydantic AI, and Docling - Core package with minimal dependencies.
`haiku.rag-slim` is the core package for users who want to install only the dependencies they need. Document processing (docling), and reranker support are all optional extras.
**For most users, we recommend installing [`haiku.rag`](https://pypi.org/project/haiku.rag/) instead**, which includes all features out of the box.
## Installation
**Python 3.12 or newer required**
### Minimal Installation
```bash
uv pip install haiku.rag-slim
```
Core functionality with OpenAI/Ollama support, MCP server, and Logfire observability. Document processing (docling) is optional.
### With Document Processing
```bash
uv pip install haiku.rag-slim[docling]
```
Adds support for 40+ file formats including PDF, DOCX, HTML, and more.
### Available Extras
**Document Processing:**
- `docling` - PDF, DOCX, HTML, and 40+ file formats
**Embedding Providers:**
- `voyageai` - VoyageAI embeddings
**Rerankers:**
- `mxbai` - MixedBread AI
- `cohere` - Cohere
- `zeroentropy` - Zero Entropy
**Model Providers:**
- OpenAI/Ollama - included in core (OpenAI-compatible APIs)
- `anthropic` - Anthropic Claude
- `groq` - Groq
- `google` - Google Gemini
- `mistral` - Mistral AI
- `bedrock` - AWS Bedrock
- `vertexai` - Google Vertex AI
```bash
# Common combinations
uv pip install haiku.rag-slim[docling,anthropic,mxbai]
uv pip install haiku.rag-slim[docling,groq,logfire]
```
## Usage
See the main [`haiku.rag`](https://github.com/ggozad/haiku.rag) repository for:
- Quick start guide
- CLI examples
- Python API usage
- MCP server setup
## Documentation
Full documentation: https://ggozad.github.io/haiku.rag/
- [Installation](https://ggozad.github.io/haiku.rag/installation/) - Provider setup
- [Configuration](https://ggozad.github.io/haiku.rag/configuration/) - YAML configuration
- [CLI](https://ggozad.github.io/haiku.rag/cli/) - Command reference
- [Python API](https://ggozad.github.io/haiku.rag/python/) - Complete API docs
| text/markdown | null | Yiorgis Gozadinos <ggozadinos@gmail.com> | null | null | MIT | RAG, lancedb, mcp, ml, vector-database | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows :: Windows 10",
"Operating System :: Microsoft :: Windows :: Windows 11",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Typing :: Typed"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"cachetools>=5.5.0",
"docling-core==2.65.1",
"haiku-skills>=0.4.2",
"httpx>=0.28.1",
"jsonpatch>=1.33",
"lancedb==0.29.2",
"pathspec>=1.0.3",
"pydantic-ai-slim[ag-ui,fastmcp,logfire,openai]>=1.46.0",
"pydantic>=2.12.5",
"python-dotenv>=1.2.1",
"pyyaml>=6.0.3",
"rich>=14.2.0",
"typer<0.22.0,>=0.21.0",
"watchfiles>=1.1.1",
"pydantic-ai-slim[anthropic]; extra == \"anthropic\"",
"pydantic-ai-slim[bedrock]; extra == \"bedrock\"",
"cohere>=5.20.1; extra == \"cohere\"",
"docling==2.73.1; extra == \"docling\"",
"opencv-python-headless>=4.13.0.90; extra == \"docling\"",
"pydantic-ai-slim[google]; extra == \"google\"",
"pydantic-ai-slim[groq]; extra == \"groq\"",
"torch>=2.0.0; extra == \"jina\"",
"transformers>=4.40.0; extra == \"jina\"",
"pydantic-ai-slim[mistral]; extra == \"mistral\"",
"mxbai-rerank>=0.1.6; extra == \"mxbai\"",
"textual-image>=0.8.5; extra == \"tui\"",
"textual>=7.3.0; extra == \"tui\"",
"pydantic-ai-slim[vertexai]; extra == \"vertexai\"",
"pydantic-ai-slim[voyageai]; extra == \"voyageai\"",
"zeroentropy>=0.1.0a7; extra == \"zeroentropy\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.12 | 2026-02-20T17:42:02.483198 | haiku_rag_slim-0.31.1.tar.gz | 105,493 | ce/20/f609117b192517dc834c15ba5c470be882f7ff9888b45dc6e1edb72327b1/haiku_rag_slim-0.31.1.tar.gz | source | sdist | null | false | 600b261bcf725e2264c039c0a4ae8f22 | 03c50c281621390d8c7ef17eb137fd1eb79310a1bdaeb744cce4acf44e66de57 | ce20f609117b192517dc834c15ba5c470be882f7ff9888b45dc6e1edb72327b1 | null | [
"LICENSE"
] | 0 |
2.4 | salesforce-data-customcode | 0.1.22 | Data Cloud Custom Code SDK | # Data Cloud Custom Code SDK (BETA)
This package provides a development kit for creating custom data transformations in [Data Cloud](https://www.salesforce.com/data/). It allows you to write your own data processing logic in Python while leveraging Data Cloud's infrastructure for data access and running data transformations, mapping execution into Data Cloud data structures like [Data Model Objects](https://help.salesforce.com/s/articleView?id=data.c360_a_data_model_objects.htm&type=5) and [Data Lake Objects](https://help.salesforce.com/s/articleView?id=sf.c360_a_data_lake_objects.htm&language=en_US&type=5).
More specifically, this codebase gives you ability to test code locally before pushing to Data Cloud's remote execution engine, greatly reducing how long it takes to develop.
Use of this project with Salesforce is subject to the [TERMS OF USE](./TERMS_OF_USE.md)
## Prerequisites
- **Python 3.11 only** (currently supported version - if your system version is different, we recommend using [pyenv](https://github.com/pyenv/pyenv) to configure 3.11)
- JDK 17
- Docker support like [Docker Desktop](https://docs.docker.com/desktop/)
- A salesforce org with some DLOs or DMOs with data and this feature enabled (it is not GA)
- **One of the following** for authentication:
- A Salesforce org already authenticated via the [Salesforce CLI](https://developer.salesforce.com/tools/salesforcecli)
(simplest — no External Client App needed)
- An [External Client App](#creating-an-external-client-app) configured with OAuth settings
## Installation
The SDK can be downloaded directly from PyPI with `pip`:
```
pip install salesforce-data-customcode
```
You can verify it was properly installed via CLI:
```
datacustomcode version
```
## Quick start
Ensure you have all the [prerequisites](#prerequisites) prepared on your machine.
To get started, create a directory and initialize a new project with the CLI:
```zsh
mkdir datacloud && cd datacloud
python3.11 -m venv .venv
source .venv/bin/activate
pip install salesforce-data-customcode
datacustomcode init my_package
```
This will yield all necessary files to get started:
```
.
├── Dockerfile
├── README.md
├── requirements.txt
├── requirements-dev.txt
├── payload
│ ├── config.json
│ ├── entrypoint.py
├── jupyterlab.sh
└── requirements.txt
```
* `Dockerfile` <span style="color:grey;font-style:italic;">(Do not update)</span> – Development container emulating the remote execution environment.
* `requirements-dev.txt` <span style="color:grey;font-style:italic;">(Do not update)</span> – These are the dependencies for the development environment.
* `jupyterlab.sh` <span style="color:grey;font-style:italic;">(Do not update)</span> – Helper script for setting up Jupyter.
* `requirements.txt` – Here you define the requirements that you will need for your script.
* `payload` – This folder will be compressed and deployed to the remote execution environment.
* `config.json` – This config defines permissions on the back and can be generated programmatically with `scan` CLI method.
* `entrypoint.py` – The script that defines the data transformation logic.
A functional entrypoint.py is provided so you can run once you've configured your External Client App:
```zsh
cd my_package
datacustomcode configure
datacustomcode run ./payload/entrypoint.py
```
> [!TIP]
> **Already using the Salesforce CLI?** If you have authenticated an org with `sf org login web
> --alias myorg`, you can skip `datacustomcode configure` entirely:
> ```zsh
> datacustomcode run ./payload/entrypoint.py --sf-cli-org myorg
> ```
> [!IMPORTANT]
> The example entrypoint.py requires a `Account_std__dll` DLO to be present. And in order to deploy the script (next step), the output DLO (which is `Account_std_copy__dll` in the example entrypoint.py) also needs to exist and be in the same dataspace as `Account_std__dll`.
After modifying the `entrypoint.py` as needed, using any dependencies you add in the `.venv` virtual environment, you can run this script in Data Cloud:
**To Add New Dependencies**:
1. Make sure your virtual environment is activated
2. Add dependencies to `requirements.txt`
3. Run `pip install -r requirements.txt`
4. The SDK automatically packages all dependencies when you run `datacustomcode zip`
```zsh
cd my_package
datacustomcode scan ./payload/entrypoint.py
datacustomcode deploy --path ./payload --name my_custom_script --cpu-size CPU_L
```
> [!TIP]
> The `deploy` process can take several minutes. If you'd like more feedback on the underlying process, you can add `--debug` to the command like `datacustomcode --debug deploy --path ./payload --name my_custom_script`
> [!NOTE]
> **CPU Size**: Choose the appropriate CPU/Compute Size based on your workload requirements:
> - **CPU_L / CPU_XL / CPU_2XL / CPU_4XL**: Large, X-Large, 2X-Large and 4X-Large CPU instances for data processing
> - Default is `CPU_2XL` which provides a good balance of performance and cost for most use cases
You can now use the Salesforce Data Cloud UI to find the created Data Transform and use the `Run Now` button to run it.
Once the Data Transform run is successful, check the DLO your script is writing to and verify the correct records were added.
## Dependency Management
The SDK automatically handles all dependency packaging for Data Cloud deployment. Here's how it works:
1. **Add dependencies to `requirements.txt`** - List any Python packages your script needs
2. **Install locally** - Use `pip install -r requirements.txt` in your virtual environment
3. **Automatic packaging** - When you run `datacustomcode zip`, the SDK automatically:
- Packages all dependencies from `requirements.txt`
- Uses the correct platform and architecture for Data Cloud
**No need to worry about platform compatibility** - the SDK handles this automatically through the Docker-based packaging process.
## files directory
```
.
├── payload
│ ├── config.json
│ ├── entrypoint.py
├── files
│ ├── data.csv
```
## py-files directory
Your Python dependencies can be packaged as .py files, .zip archives (containing multiple .py files or a Python package structure), or .egg files.
```
.
├── payload
│ ├── config.json
│ ├── entrypoint.py
├── py-files
│ ├── moduleA
│ │ ├── __init__.py
│ │ ├── moduleA.py
```
## API
Your entry point script will define logic using the `Client` object which wraps data access layers.
You should only need the following methods:
* `find_file_path(file_name)` - Returns a file path
* `read_dlo(name)` – Read from a Data Lake Object by name
* `read_dmo(name)` – Read from a Data Model Object by name
* `write_to_dlo(name, spark_dataframe, write_mode)` – Write to a Data Model Object by name with a Spark dataframe
* `write_to_dmo(name, spark_dataframe, write_mode)` – Write to a Data Lake Object by name with a Spark dataframe
For example:
```
from datacustomcode import Client
client = Client()
sdf = client.read_dlo('my_DLO')
# some transformations
# ...
client.write_to_dlo('output_DLO')
```
> [!WARNING]
> Currently we only support reading from DMOs and writing to DMOs or reading from DLOs and writing to DLOs, but they cannot mix.
## CLI
The Data Cloud Custom Code SDK provides a command-line interface (CLI) with the following commands:
### Global Options
- `--debug`: Enable debug-level logging
### Commands
#### `datacustomcode version`
Display the current version of the package.
#### `datacustomcode configure`
Configure credentials for connecting to Data Cloud.
**Prerequisites:**
- An [External Client App](#creating-an-external-client-app) with OAuth settings configured
- For OAuth Tokens authentication: [refresh token and core token](#obtaining-refresh-token-and-core-token)
Options:
- `--profile TEXT`: Credential profile name (default: "default")
- `--auth-type TEXT`: Authentication method (default: `oauth_tokens`)
- `oauth_tokens` - OAuth tokens with refresh_token
- `client_credentials` - Server-to-server using client_id/secret only
You will be prompted for the following depending on auth type:
*Common to all auth types:*
- **Login URL**: Salesforce login URL
- **Client ID**: External Client App Client ID
*For OAuth Tokens authentication:*
- **Client Secret**: External Client App Client Secret
- **Redirect URI**: OAuth redirect URI
*For Client Credentials authentication:*
- **Client Secret**: External Client App Client Secret
##### Using Environment Variables (Alternative)
Instead of using `datacustomcode configure`, you can also set credentials via environment variables.
> [!NOTE]
> Environment variables take precedence over the credentials INI file when both are present.
**Common (required for all auth types):**
| Variable | Description |
|----------|-------------|
| `SFDC_LOGIN_URL` | Salesforce login URL (e.g., `https://login.salesforce.com`) |
| `SFDC_CLIENT_ID` | External Client App Client ID |
| `SFDC_AUTH_TYPE` | Authentication type: `oauth_tokens` (default) or `client_credentials` |
**For OAuth Tokens authentication (`SFDC_AUTH_TYPE=oauth_tokens`):**
| Variable | Description |
|----------|-------------|
| `SFDC_CLIENT_SECRET` | External Client App Client Secret |
| `SFDC_REFRESH_TOKEN` | OAuth refresh token |
| `SFDC_ACCESS_TOKEN` | (Optional) OAuth core/access token |
Example usage:
```bash
export SFDC_LOGIN_URL="https://login.salesforce.com"
export SFDC_CLIENT_ID="your_client_id"
export SFDC_CLIENT_SECRET="your_client_secret"
export SFDC_REFRESH_TOKEN="your_refresh_token"
datacustomcode run ./payload/entrypoint.py
```
#### `datacustomcode init`
Initialize a new development environment with a code package template.
Argument:
- `DIRECTORY`: Directory to create project in (default: ".")
#### `datacustomcode scan`
Scan a Python file to generate a Data Cloud configuration.
Argument:
- `FILENAME`: Python file to scan
Options:
- `--config TEXT`: Path to save the configuration file (default: same directory as FILENAME)
- `--dry-run`: Preview the configuration without saving to a file
#### `datacustomcode run`
Run an entrypoint file locally for testing.
Argument:
- `ENTRYPOINT`: Path to entrypoint Python file
Options:
- `--config-file TEXT`: Path to configuration file
- `--dependencies TEXT`: Additional dependencies (can be specified multiple times)
- `--profile TEXT`: Credential profile name (default: "default")
- `--sf-cli-org TEXT`: Salesforce CLI org alias or username (e.g. `dev1`). Fetches
credentials via `sf org display` — no `datacustomcode configure` step needed.
Takes precedence over `--profile` if both are supplied.
#### `datacustomcode zip`
Zip a transformation job in preparation to upload to Data Cloud. Make sure to change directory into your code package folder (e.g., `my_package`) before running this command.
Arguments:
- `PATH`: Path to the code directory i.e. the payload folder (default: "payload")
Options:
- `--network TEXT`: docker network (default: "default")
#### `datacustomcode deploy`
Deploy a transformation job to Data Cloud. Note that this command takes care of creating a zip file from provided path before deployment. Make sure to change directory into your code package folder (e.g., `my_package`) before running this command.
Options:
- `--profile TEXT`: Credential profile name (default: "default")
- `--path TEXT`: Path to the code directory i.e. the payload folder (default: ".")
- `--name TEXT`: Name of the transformation job [required]
- `--version TEXT`: Version of the transformation job (default: "0.0.1")
- `--description TEXT`: Description of the transformation job (default: "")
- `--network TEXT`: docker network (default: "default")
- `--cpu-size TEXT`: CPU size for the deployment (default: `CPU_2XL`). Available options: CPU_L(Large), CPU_XL(Extra Large), CPU_2XL(2X Large), CPU_4XL(4X Large)
## Docker usage
The SDK provides Docker-based development options that allow you to test your code in an environment that closely resembles Data Cloud's execution environment.
### How Docker Works with the SDK
When you initialize a project with `datacustomcode init my_package`, a `Dockerfile` is created automatically. This Dockerfile:
- **Isn't used during local development** with virtual environments
- **Becomes active during packaging** when you run `datacustomcode zip` or `deploy`
- **Ensures compatibility** by using the same base image as Data Cloud
- **Handles dependencies automatically** regardless of platform differences
### VS Code Dev Containers
Within your `init`ed package, you will find a `.devcontainer` folder which allows you to run a docker container while developing inside of it.
Read more about Dev Containers here: https://code.visualstudio.com/docs/devcontainers/containers.
#### Setup Instructions
1. Install the VS Code extension "Dev Containers" by microsoft.com.
2. Open your package folder in VS Code, ensuring that the `.devcontainer` folder is
at the root of the File Explorer
3. Bring up the Command Palette (on mac: Cmd + Shift + P), and select "Dev
Containers: Rebuild and Reopen in Container"
4. Allow the docker image to be built, then you're ready to develop
#### Development Workflow
Once inside the Dev Container:
- **Terminal access**: Open a terminal within the container
- **Run your code**: Execute `datacustomcode run ./payload/entrypoint.py`
- **Environment consistency**: Your code will run inside a docker container that more closely resembles Data Cloud compute than your machine
> [!TIP]
> **IDE Configuration**: Use `CMD+Shift+P` (or `Ctrl+Shift+P` on Windows/Linux), then select "Python: Select Interpreter" to configure the correct Python Interpreter
> [!IMPORTANT]
> Dev Containers get their own tmp file storage, so you'll need to re-run `datacustomcode configure` every time you "Rebuild and Reopen in Container".
### JupyterLab
Within your `init`ed package, you will find a `jupyterlab.sh` file that can open a jupyter notebook for you. Jupyter notebooks, in
combination with Data Cloud's [Query Editor](https://help.salesforce.com/s/articleView?id=data.c360_a_add_queries_to_a_query_workspace.htm&type=5)
and [Data Explorer](https://help.salesforce.com/s/articleView?id=data.c360_a_data_explorer.htm&type=5), can be extremely helpful for data
exploration. Instead of running an entire script, one can run one code cell at a time as they discover and experiment with the DLO or DMO data.
You can read more about Jupyter Notebooks here: https://jupyter.org/
1. Within the root project of your package folder, run `./jupyterlab.sh start`
1. Double-click on "account.ipynb" file, which provides a starting point for a notebook
1. Use shift+enter to execute each cell within the notebook. Add/edit/delete cells of code as needed for your data exploration.
1. Don't forget to run `./jupyterlab.sh stop` to stop the docker container
> [!IMPORTANT]
> JupyterLab uses its own tmp file storage, so you'll need to re-run `datacustomcode configure` each time you `./jupyterlab.sh start`.
## Prerequisite details
### Creating an External Client app
1. Log in to Salesforce as an admin. In the top right corner, click on the gear icon and go to `Setup`
2. On the left sidebar, expand `Apps`, expand `External Client Apps`, click `Settings`
3. Expand `Apps`, expand `External Client Apps`, click `External Client App Manager`
4. Click `New External Client App` button
5. Fill in the required fields within the `Basic Information` section
6. Under the `API (Enable OAuth Settings)` section:
1. Click on the checkbox to Enable OAuth Settings
2. Provide a callback URL like `http://localhost:5555/callback`
3. In the Selected OAuth Scopes, make sure that `refresh_token`, `api`, `cdp_query_api`, `cdp_profile_api` are selected
4. Check the following:
- Enable Authorization Code and Credentials Flow
- Require user credentials in the POST body for Authorization Code and Credentials Flow
5. Uncheck `Require Proof Key for Code Exchange (PKCE) extension for Supported Authorization Flows`
6. Click on `Create` button
7. On your newly created External Client App page, on the `Policies` tab:
1. In the `App Authorization` section, choose an appropriate Refresh Token Policy as per your expected usage and preference.
2. Under `App Authorization`, set IP Relaxation to `Relax IP restrictions` unless otherwise needed
8. Click `Save`
9. Go to the `Settings` tab, under `OAuth Settings`. There, you can click on the `Consumer Key and Secret` button which will open a new tab. There you can copy the `client_id` and `client_secret` values which are to be used during configuring credentials using this SDK.
10. Logout
11. Use the URL of the login page as the `login_url` value when setting up the SDK
You now have all fields necessary for the `datacustomcode configure` command.
### Using the Salesforce CLI for authentication
The [Salesforce CLI](https://developer.salesforce.com/tools/salesforcecli) (`sf`) lets you authenticate an org once and then reference it by alias across tools — including this SDK via `--sf-cli-org`.
#### Installing the Salesforce CLI
Follow the [official install guide](https://developer.salesforce.com/docs/atlas.en-us.sfdx_setup.meta/sfdx_setup/sfdx_setup_install_cli.htm), or use a package manager:
```zsh
# macOS (Homebrew)
brew install sf
# npm (all platforms)
npm install --global @salesforce/cli
```
Verify the install:
```zsh
sf --version
```
#### Authenticating an org
**Browser-based (recommended for developer orgs and sandboxes):**
```zsh
# Production / Developer Edition
sf org login web --alias myorg
# Sandbox
sf org login web --alias mysandbox --instance-url https://test.salesforce.com
# Custom domain
sf org login web --alias myorg --instance-url https://mycompany.my.salesforce.com
```
Each command opens a browser tab. After you log in and approve access, the CLI stores the session locally.
**Verify the stored org and confirm the alias:**
```zsh
sf org list
sf org display --target-org myorg
```
Once authenticated, pass the alias directly to `datacustomcode run`:
```zsh
datacustomcode run ./payload/entrypoint.py --sf-cli-org myorg
```
### Obtaining Refresh Token and Core Token
If you're using OAuth Tokens authentication, the initial configure will retrieve and store tokens. Run `datacustomcode auth` to refresh these when they expire.
## Other docs
- [Troubleshooting](./docs/troubleshooting.md)
- [For Contributors](./FOR_CONTRIBUTORS.md)
| text/markdown | null | null | null | null | null | null | [
"Development Status :: 4 - Beta",
"Operating System :: Unix",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11"
] | [] | null | null | <3.12,>=3.10 | [] | [] | [] | [
"click<9.0.0,>=8.1.8",
"loguru<0.8.0,>=0.7.3",
"numpy",
"pandas",
"pydantic<3.0.0,>=1.8.2",
"pyspark==3.5.1",
"pyyaml<7.0,>=6.0",
"salesforce-cdp-connector>=1.0.19",
"setuptools_scm<8.0.0,>=7.1.0"
] | [] | [] | [] | [] | poetry/2.3.2 CPython/3.11.14 Linux/6.11.0-1018-azure | 2026-02-20T17:41:40.371551 | salesforce_data_customcode-0.1.22-py3-none-any.whl | 79,091 | 83/36/ecdc9f3ce94121e1f0cb3e784a710e7cc2977b6d9cbb7d0acfab9f624185/salesforce_data_customcode-0.1.22-py3-none-any.whl | py3 | bdist_wheel | null | false | 7afbc94fee87384ee990c82a9e13ccce | e14dbccbea5161e7ca008a5ff867e07a13b80bb2f52522d4583bf1a26f99b182 | 8336ecdc9f3ce94121e1f0cb3e784a710e7cc2977b6d9cbb7d0acfab9f624185 | Apache-2.0 | [
"LICENSE.txt"
] | 175 |
2.4 | honeybee-schema | 2.0.3 | Honeybee Data-Model Objects | [](https://travis-ci.com/ladybug-tools/honeybee-schema)
[](https://coveralls.io/github/ladybug-tools/honeybee-schema)
[](https://www.python.org/downloads/release/python-370/)
# honeybee-schema
Honeybee Data-Model Objects
This code was partially developed under the [Wells Fargo Innovation Incubator grant](https://newsroom.wf.com/press-release/community/five-clean-tech-startups-added-wells-fargo-innovation-incubator) with help from the
[OpenStudio Team](https://github.com/NREL/OpenStudio) at [NREL](https://www.nrel.gov/).
# Installation
To install the core library use:
`pip install -U honeybee-schema`
If you want to also include the command line interface use:
`pip install -U honeybee-schema[cli]`
## QuickStart
```python
import honeybee_schema
```
## API Documentation
[Schema Overview](https://github.com/ladybug-tools/honeybee-schema/wiki)
[Model Schema Specification](https://ladybug-tools.github.io/honeybee-schema/model.html)
[Energy Simulation Parameter Schema Specification](https://ladybug-tools.github.io/honeybee-schema/simulation-parameter.html)
## Local Development
1. Clone this repo locally
```console
git clone git@github.com:ladybug-tools/honeybee-schema
# or
git clone https://github.com/ladybug-tools/honeybee-schema
```
2. Install dependencies:
```console
cd honeybee-schema
pip install -r dev-requirements.txt
pip install -r requirements.txt
```
3. Run Tests:
```console
python -m pytest tests/
```
4. Generate Documentation:
```python
python ./docs.py
```
5. Generate Sample Files:
```python
python ./scripts/export_samples.py
```
| text/markdown | Ladybug Tools | info@ladybug.tools | null | null | BSD-3-Clause | null | [
"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 :: Implementation :: CPython",
"Operating System :: OS Independent"
] | [] | https://github.com/ladybug-tools-in2/honeybee-schema | null | null | [] | [] | [] | [
"pydantic-openapi-helper==1.0.3",
"honeybee-standards==2.0.7",
"click>=7.1.2; extra == \"cli\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.12.12 | 2026-02-20T17:41:23.996296 | honeybee_schema-2.0.3.tar.gz | 66,585 | 9f/bc/85f39a843dfe66e4ce9633a5bc3a24be0dae4d9592a076c65d7996b4b132/honeybee_schema-2.0.3.tar.gz | source | sdist | null | false | ac04714e5b4374719729299bfa088441 | ed75f953fec67fe7e8c8911bf510cc23e94d00eb48d39850cdc5102bd68aca3d | 9fbc85f39a843dfe66e4ce9633a5bc3a24be0dae4d9592a076c65d7996b4b132 | null | [
"LICENSE"
] | 1,183 |
2.4 | gtsam-develop | 4.3a1.dev202602201611 | Georgia Tech Smoothing And Mapping library | # GTSAM: Georgia Tech Smoothing and Mapping Library
[](https://gtsam.org/doxygen/)
[](https://borglab.github.io/gtsam/)
**Important Note**
**The `develop` branch is officially in "Pre 4.3" mode. We envision several API-breaking changes as we switch to C++17 and away from boost.**
In addition, features deprecated in 4.2 will be removed. Please use the stable [4.2 release](https://github.com/borglab/gtsam/releases/tag/4.2) if you need those features. However, most are easily converted and can be tracked down (in 4.2) by disabling the cmake flag `GTSAM_ALLOW_DEPRECATED_SINCE_V42`.
## What is GTSAM?
GTSAM is a C++ library that implements smoothing and
mapping (SAM) in robotics and vision, using Factor Graphs and Bayes
Networks as the underlying computing paradigm rather than sparse
matrices.
<!-- Main CI Badges (develop branch) -->
| CI Status | Platform | Compiler |
|:----------|:---------|:---------|
| [](https://github.com/borglab/gtsam/actions/workflows/build-python.yml?query=branch%3Adevelop) | Ubuntu 22.04, MacOS 13-14, Windows | gcc/clang,MSVC |
| [](https://github.com/borglab/gtsam/actions/workflows/vcpkg.yml?query=branch%3Adevelop) | Latest Windows/Ubuntu/Mac | - |
| [](https://github.com/borglab/gtsam/actions/workflows/build-cibw.yml?query=branch%3Adevelop) | See [pypi files](https://pypi.org/project/gtsam-develop/#files); no Windows| - |
On top of the C++ library, GTSAM includes [wrappers for MATLAB & Python](#wrappers).
## Documentation
- **C++ API Docs:** [https://gtsam.org/doxygen/](https://gtsam.org/doxygen/)
- **Python API Docs:** [https://borglab.github.io/gtsam/](https://borglab.github.io/gtsam/)
<!-- TODO: Perhaps include links to source code as well? But the wrappers doesn't really help too much understanding the source code.
C++: https://github.com/borglab/gtsam/tree/develop/gtsam
Matlab wrapper: https://github.com/borglab/gtsam/blob/develop/matlab/README.md
Python wrapper https://github.com/borglab/gtsam/blob/develop/python/README.md
-->
## Quickstart
In the root library folder execute:
```sh
#!bash
mkdir build
cd build
cmake ..
make check # optional, runs all unit tests
make install
```
Prerequisites:
- A modern compiler:
- Mac: at least xcode-14.2
- Linux: at least clang-11 or gcc-9
- Windows: at least msvc-14.2
- [CMake](http://www.cmake.org/cmake/resources/software.html) >= 3.9
- Ubuntu: `sudo apt-get install cmake`
Optional Boost prerequisite:
Boost is now *optional*. Two cmake flags govern its behavior:
- `GTSAM_USE_BOOST_FEATURES` = `ON|OFF`: some of our timers and concept checking in the tests still depend on boost.
- `GTSAM_ENABLE_BOOST_SERIALIZATION` = `ON|OFF`: serialization of factor graphs, factors, etc still is done using boost
If one or both of these flags are `ON`, you need to install [Boost](http://www.boost.org/users/download/) >= 1.70
- Mac: `brew install boost`
- Ubuntu: `sudo apt-get install libboost-all-dev`
- Windows: We highly recommend using the [vcpkg](https://github.com/microsoft/vcpkg) package manager. For other installation methods or troubleshooting, please see the guidance in the [cmake/HandleBoost.cmake](cmake/HandleBoost.cmake) script.
Optional prerequisites - used automatically if findable by CMake:
- [Intel Threaded Building Blocks (TBB)](http://www.threadingbuildingblocks.org/) (Ubuntu: `sudo apt-get install libtbb-dev`)
- [Intel Math Kernel Library (MKL)](http://software.intel.com/en-us/intel-mkl) (Ubuntu: [installing using APT](https://software.intel.com/en-us/articles/installing-intel-free-libs-and-python-apt-repo))
- See [INSTALL.md](INSTALL.md) for more installation information
- Note that MKL may not provide a speedup in all cases. Make sure to benchmark your problem with and without MKL.
## GTSAM 4 Compatibility
GTSAM 4 introduces several new features, most notably Expressions and a Python toolbox. It also introduces traits, a C++ technique that allows optimizing with non-GTSAM types. That opens the door to retiring geometric types such as Point2 and Point3 to pure Eigen types, which we also do. A significant change which will not trigger a compile error is that zero-initializing of Point2 and Point3 is deprecated, so please be aware that this might render functions using their default constructor incorrect.
There is a flag `GTSAM_ALLOW_DEPRECATED_SINCE_V43` for newly deprecated methods since the 4.3 release, which is on by default, allowing anyone to just pull version 4.3 and compile.
## Wrappers
We provide support for [MATLAB](matlab/README.md) and [Python](python/README.md) wrappers for GTSAM. Please refer to the linked documents for more details.
## Citation
If you are using GTSAM for academic work, please use the following citation:
```bibtex
@software{gtsam,
author = {Frank Dellaert and GTSAM Contributors},
title = {borglab/gtsam},
month = May,
year = 2022,
publisher = {Georgia Tech Borg Lab},
version = {4.2a8},
doi = {10.5281/zenodo.5794541},
url = {https://github.com/borglab/gtsam)}}
}
```
To cite the `Factor Graphs for Robot Perception` book, please use:
```bibtex
@book{factor_graphs_for_robot_perception,
author={Frank Dellaert and Michael Kaess},
year={2017},
title={Factor Graphs for Robot Perception},
publisher={Foundations and Trends in Robotics, Vol. 6},
url={http://www.cs.cmu.edu/~kaess/pub/Dellaert17fnt.pdf}
}
```
If you are using the IMU preintegration scheme, please cite:
```bibtex
@book{imu_preintegration,
author={Christian Forster and Luca Carlone and Frank Dellaert and Davide Scaramuzza},
title={IMU preintegration on Manifold for Efficient Visual-Inertial Maximum-a-Posteriori Estimation},
year={2015}
}
```
## The Preintegrated IMU Factor
GTSAM includes a state of the art IMU handling scheme based on
- Todd Lupton and Salah Sukkarieh, _"Visual-Inertial-Aided Navigation for High-Dynamic Motion in Built Environments Without Initial Conditions"_, TRO, 28(1):61-76, 2012. [[link]](https://ieeexplore.ieee.org/document/6092505)
Our implementation improves on this using integration on the manifold, as detailed in
- Luca Carlone, Zsolt Kira, Chris Beall, Vadim Indelman, and Frank Dellaert, _"Eliminating conditionally independent sets in factor graphs: a unifying perspective based on smart factors"_, Int. Conf. on Robotics and Automation (ICRA), 2014. [[link]](https://ieeexplore.ieee.org/abstract/document/6907483)
- Christian Forster, Luca Carlone, Frank Dellaert, and Davide Scaramuzza, _"IMU Preintegration on Manifold for Efficient Visual-Inertial Maximum-a-Posteriori Estimation"_, Robotics: Science and Systems (RSS), 2015. [[link]](http://www.roboticsproceedings.org/rss11/p06.pdf)
If you are using the factor in academic work, please cite the publications above.
In GTSAM 4 a new and more efficient implementation, based on integrating on the NavState tangent space and detailed in [this document](doc/ImuFactor.pdf), is enabled by default. To switch to the RSS 2015 version, set the flag `GTSAM_TANGENT_PREINTEGRATION` to OFF.
## Additional Information
There is a [GTSAM users Google group](https://groups.google.com/forum/#!forum/gtsam-users) for general discussion.
Read about important [GTSAM-Concepts](doc/GTSAM-Concepts.md) here. A primer on GTSAM Expressions,
which support (superfast) automatic differentiation,
can be found on the [GTSAM wiki on BitBucket](https://bitbucket.org/gtborg/gtsam/wiki/Home).
See the [`INSTALL`](INSTALL.md) file for more detailed installation instructions. Our CI/CD process is detailed in [workflows.md](doc/workflows.md).
GTSAM is open source under the BSD license, see the [`LICENSE`](LICENSE) and [`LICENSE.BSD`](LICENSE.BSD) files.
Please see the [`examples/`](examples) directory and the [`USAGE`](USAGE.md) file for examples on how to use GTSAM.
GTSAM was developed in the lab of [Frank Dellaert](http://www.cc.gatech.edu/~dellaert) at the [Georgia Institute of Technology](http://www.gatech.edu), with the help of many contributors over the years, see [THANKS](THANKS.md).
| text/markdown | Frank Dellaert et. al. | frank.dellaert@gtsam.org | null | null | Simplified BSD license | slam sam robotics localization mapping optimization | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Education",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows",
"Operating System :: POSIX",
"License :: OSI Approved :: BSD License",
"Programming Language :: Python :: 3"
] | [] | https://gtsam.org/ | null | null | [] | [] | [] | [
"numpy>=1.11.0",
"pytest>=9.0.1"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:41:23.137961 | gtsam_develop-4.3a1.dev202602201611-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl | 29,025,815 | 8c/20/3192bd12f8fceb96381a026b40b46e218fcdc703c807d098d5c2c1233575/gtsam_develop-4.3a1.dev202602201611-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl | cp314 | bdist_wheel | null | false | e9beb23c10e73ef30f6257fd10ff6748 | af18e7694af31490fa6633952e23b8053788e597654789fe186245b7e021aece | 8c203192bd12f8fceb96381a026b40b46e218fcdc703c807d098d5c2c1233575 | null | [] | 618 |
2.1 | remotion-lambda | 4.0.427 | Remotion Lambda client | Remotion is a framework for creating videos programmatically using React.
| text/markdown | Jonny Burger | jonny@remotion.dev | null | null | null | null | [] | [] | https://github.com/remotion-dev/remotion/tree/main/packages/lambda-python | null | >=3.6 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.12 | 2026-02-20T17:41:06.104503 | remotion_lambda-4.0.427.tar.gz | 19,392 | eb/ff/be8805112020667eaa3d7b79c30c2d0aa506d7cc6113f875ade5c4841263/remotion_lambda-4.0.427.tar.gz | source | sdist | null | false | 21b573bfac1ffcfc27fabaee48802f1a | 8c114c7c5762c0722bb69f78cd20046f886fd1cee9285a77c3d6bc847ca7d757 | ebffbe8805112020667eaa3d7b79c30c2d0aa506d7cc6113f875ade5c4841263 | null | [] | 180 |
2.4 | inspect-ai | 0.3.180 | Framework for large language model evaluations | [<img width="295" src="https://inspect.aisi.org.uk/images/aisi-logo.svg" />](https://aisi.gov.uk/)
Welcome to Inspect, a framework for large language model evaluations created by the [UK AI Security Institute](https://aisi.gov.uk/).
Inspect provides many built-in components, including facilities for prompt engineering, tool usage, multi-turn dialog, and model graded evaluations. Extensions to Inspect (e.g. to support new elicitation and scoring techniques) can be provided by other Python packages.
To get started with Inspect, please see the documentation at <https://inspect.aisi.org.uk/>.
Inspect also includes a collection of over 100 pre-built evaluations ready to run on any model (learn more at [Inspect Evals](https://ukgovernmentbeis.github.io/inspect_evals/))
***
To work on development of Inspect, clone the repository and install with the `-e` flag and `[dev]` optional dependencies:
```bash
git clone https://github.com/UKGovernmentBEIS/inspect_ai.git
cd inspect_ai
pip install -e ".[dev]"
```
Optionally install pre-commit hooks via
```bash
make hooks
```
Run linting, formatting, and tests via
```bash
make check
make test
```
If you use VS Code, you should be sure to have installed the recommended extensions (Python, Ruff, and MyPy). Note that you'll be prompted to install these when you open the project in VS Code.
***
To work on the Inspect documentation, install the optional `[doc]` dependencies with the `-e` flag and build the docs:
```
pip install -e ".[doc]"
cd docs
quarto render # or 'quarto preview'
```
If you intend to work on the docs iteratively, you'll want to install the Quarto extension in VS Code.
| text/markdown | UK AI Security Institute | null | null | null | MIT License | null | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Science/Research",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Programming Language :: Python :: 3",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Typing :: Typed",
"Operating System :: OS Independent"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"aioboto3>=13.0.0",
"aiohttp>=3.9.0",
"anyio>=4.8.0",
"beautifulsoup4>=4.10.0",
"boto3",
"click!=8.2.0,<8.2.2,>=8.1.3",
"debugpy",
"docstring-parser>=0.16",
"exceptiongroup>=1.0.2; python_version < \"3.11\"",
"frozendict>=2.4.6",
"fsspec<=2025.9.0,>=2023.1.0",
"httpx",
"ijson>=3.2.0",
"jsonlines>=3.0.0",
"jsonpatch>=1.32",
"jsonpath-ng>=1.6.0",
"jsonref>=1.1.0",
"jsonschema>3.1.1",
"mmh3>3.1.0",
"nest_asyncio2",
"numpy",
"platformdirs>=2.3.0",
"psutil",
"pydantic>=2.11.4",
"python-dotenv>=0.16.0",
"pyyaml",
"rich!=14.0.0,>=13.3.3",
"s3fs>=2023",
"semver>=3.0.0",
"shortuuid",
"sniffio",
"tenacity",
"textual>=2.1.0",
"tiktoken>=0.12.0",
"typing_extensions>=4.9.0",
"universal-pathlib>=0.2.6",
"zipfile-zstd>=0.0.4; python_version < \"3.14\"",
"zipp>=3.19.1",
"zstandard>=0.20.0",
"adlfs>=2025.8.0; extra == \"dev\"",
"anthropic>=0.80.0; extra == \"dev\"",
"azure-identity; extra == \"dev\"",
"azure-ai-inference; extra == \"dev\"",
"fastapi; extra == \"dev\"",
"google-genai>=1.56.0; extra == \"dev\"",
"griffe<=1.14.0; extra == \"dev\"",
"groq>=0.28.0; extra == \"dev\"",
"huggingface_hub>=1.0.0; extra == \"dev\"",
"inspect_scout; extra == \"dev\"",
"ipython; extra == \"dev\"",
"jsonpath-ng; extra == \"dev\"",
"markdown; extra == \"dev\"",
"mcp>=1.10.0; extra == \"dev\"",
"mistralai>=1.9.11; extra == \"dev\"",
"moto[server]; extra == \"dev\"",
"mypy>=1.17.0; extra == \"dev\"",
"nbformat; extra == \"dev\"",
"openai>=2.17.0; extra == \"dev\"",
"pandas>=2.0.0; extra == \"dev\"",
"panflute; extra == \"dev\"",
"pip; extra == \"dev\"",
"pre-commit; extra == \"dev\"",
"pyarrow>=10.0.1; extra == \"dev\"",
"pylint; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pytest-asyncio; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest-dotenv; extra == \"dev\"",
"pytest-mock; extra == \"dev\"",
"pytest-watcher; extra == \"dev\"",
"pytest-xdist; extra == \"dev\"",
"ruff==0.9.6; extra == \"dev\"",
"together>=2.0.0; extra == \"dev\"",
"textual-dev>=0.86.2; extra == \"dev\"",
"trio; extra == \"dev\"",
"pandas-stubs; extra == \"dev\"",
"pyarrow-stubs; extra == \"dev\"",
"types-grpcio; extra == \"dev\"",
"types-Markdown; extra == \"dev\"",
"types-PyYAML; extra == \"dev\"",
"types-beautifulsoup4; extra == \"dev\"",
"types-aioboto3; extra == \"dev\"",
"types-boto3; extra == \"dev\"",
"types-botocore; extra == \"dev\"",
"types-jsonpatch; extra == \"dev\"",
"types-jsonschema; extra == \"dev\"",
"types-protobuf; extra == \"dev\"",
"types-psutil; extra == \"dev\"",
"types-python-dateutil; extra == \"dev\"",
"xai_sdk>=1.4.0; extra == \"dev\"",
"uvicorn; extra == \"dev\"",
"zipfile-zstd>=0.0.4; python_version < \"3.14\" and extra == \"dev\"",
"mcp-server-fetch; extra == \"dev-mcp-tests\"",
"mcp_server_git; extra == \"dev-mcp-tests\"",
"quarto-cli==1.7.32; extra == \"doc\"",
"jupyter; extra == \"doc\"",
"panflute; extra == \"doc\"",
"markdown; extra == \"doc\"",
"griffe<=1.14.0; extra == \"doc\"",
"click>=8.2.0; extra == \"doc\"",
"twine; extra == \"dist\"",
"build; extra == \"dist\""
] | [] | [] | [] | [
"Documentation, https://inspect.aisi.org.uk/",
"Source Code, https://github.com/UKGovernmentBEIS/inspect_ai",
"Issue Tracker, https://github.com/UKGovernmentBEIS/inspect_ai/issues"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T17:40:57.250021 | inspect_ai-0.3.180.tar.gz | 43,788,652 | 72/a2/6e3ec0a5a962e7e73abf01b54ee51c5904b13c7070a9385630e19fd63f4a/inspect_ai-0.3.180.tar.gz | source | sdist | null | false | e57136bac3c7c9b670c9a7ad2eac7ff8 | 39bcea0014789daa57308239512ff9dce3dddee828e9c7c800461d212dc56e9c | 72a26e3ec0a5a962e7e73abf01b54ee51c5904b13c7070a9385630e19fd63f4a | null | [
"LICENSE"
] | 3,826 |
2.4 | mas-cli | 18.17.1 | Python Admin CLI for Maximo Application Suite | mas.devops
----------
Example
=======
.. code:: python
from openshift import dynamic
from kubernetes import config
from kubernetes.client import api_client
from mas.devops.ocp import createNamespace
from mas.devops.tekton import installOpenShiftPipelines, updateTektonDefinitions, launchUpgradePipeline
instanceId = "mymas"
pipelinesNamespace = f"mas-{instanceId}-pipelines"
# Create an OpenShift client
dynClient = dynamic.DynamicClient(
api_client.ApiClient(configuration=config.load_kube_config())
)
# Install OpenShift Pipelines Operator
success = installOpenShiftPipelines(dynamicClient)
assert success is True
# Create the pipelines namespace and install the MAS tekton definitions
createNamespace(dynamicClient, pipelinesNamespace)
updateTektonDefinitions(pipelinesNamespace)
# Launch the upgrade pipeline and print the URL to view the pipeline run
pipelineURL = launchUpgradePipeline(self.dynamicClient, instanceId)
print(pipelineURL)
| null | David Parker | parkerda@uk.ibm.com | null | null | Eclipse Public License - v1.0 | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Operating System :: Microsoft :: Windows",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python",
"Programming Language :: Python :: 3.12",
"Topic :: Communications",
"Topic :: Internet",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | https://github.com/ibm-mas/cli | null | null | [] | [] | [] | [
"mas-devops>=5.2.0",
"halo",
"prompt_toolkit",
"openshift",
"kubernetes==33.1.0",
"tabulate",
"build; extra == \"dev\"",
"flake8; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pyinstaller; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:40:56.020522 | mas_cli-18.17.1.tar.gz | 252,378 | a3/7e/8f35f77efd7b0a9cc48790dc79f9476ed5cbce5584635cf772ac8a66d9b6/mas_cli-18.17.1.tar.gz | source | sdist | null | false | a064def3de59916da2f8d16541e4a8b2 | e7b3d035c4c1c77cf0abf8e944cc7e243fed5fe4a3a560f717c1be7b18e46539 | a37e8f35f77efd7b0a9cc48790dc79f9476ed5cbce5584635cf772ac8a66d9b6 | null | [] | 165 |
2.1 | csrk | 0.1.4 | Python tools for CSRK rust Gaussian Process crate | <img src=csrk_Nighthawks.jpg>
(image interpolated from scan of Nighthawks by Edward Hopper -- 1942 -- public domain)
# Gaussian Process Regression with Compactly Supported Radial Kernel
<a href=https://crates.io/crates/csrk target="_blank">csrk</a> is a Rust crate for large-scale Gaussian Process regression using compactly supported Wendland kernels, spatial hashing, and sparse LDL^T factorization. It enables training on tens of thousands of points and fast sampling and evaluation of GP realizations with near-constant per-query cost.
It is a CPU-based code implementing the Wendland kernels (piecewise polynomial kernels with compact support) using the <a href=https://github.com/sparsemat/sprs target="_blank">sprs</a> crates for sparse matrix operations (<a href=https://crates.io/crates/sprs target="_blank">sprs</a>) and sparse Cholesky decomposition (<a href=https://crates.io/crates/sprs-ldl>sprs-ldl</a>).
This Python API calls out to that Rust crate and instantiates a
Hybrid Python/Rust Gaussian Process, capable of most of the methods
and features included in the Rust representation.
## Installation
Installation of the source distribution may require having the rust compiler Cargo installed.
#### From Pypi
```bash
pip install csrk
```
#### From source
```bash
git clone https://gitlab.com/xevra/csrk-py
cd csrk-py
pip install .
```
## Example
```python
from csrk import HybridGP
gp = HybridGP(
x_train, # NumPy array of shape (n_pts, n_dimensions) -- Array of arrays of points
y_train, # NumPy array of shape (n_pts,) -- Array of values
y_err, # NumPy array of shape (n_pts,) -- Training error -- how reliable is each point?
scale, # NumPy array of shape (n_dimensions,) -- determines sparsity
whitenoise, # float -- Can safely be zero for non-noisy data
order, # int \in (0, 1, 2, 3) -- Try 1 first
)
y_evals = gp.predict_mean(x_evals)
```
## Features
- compactly supported Wendland kernels
- sparse kernel construction via spatial hashing
- scalable sparse LDL^T training
- Serialization in hdf5
- No dependency on scikit-sparse
For more on the performance of the Rust GP and an overview of the
modules and algorith, see the
<a href=https://gitlab.com/xevra/csrk target="_blank">Rust crate gitlab</a>.
## Motivation
The Wendland kernels can be used for training and evaluating GPR interpolators in O(n * m), for n evaluation points and m nearest neighbors. This also affects the Cholesky decomposition of the kernel.
When done properly, this process conserves both compute time and computer memory, as large (n x n) arrays are never allocated.
Previously, I had developed a separate Python library for doing this: (<a href=https://gitlab.com/xevra/gaussian-process-api target="_blank">gaussian-process-api</a>). However, despite the use of sparse matrices in the Cholesky decomposition (using scikit-sparse), and despite the C extension backend for the kernel evaluations, this library still constructs dense array intermediate products which may challenge memory resources.
By writing a new module in Rust, I would like to remove the dependency on scikit-sparse and avoid storing large dense matrices in memory at any point throughout the computation, allowing for a lightweight and fast Gaussian Process regression implementation.
## Contributing
I am open to suggestions and pull requests.
## Acknowledgements
My background in Gaussian Processes, and the Wenland kernels come from <a href=https://direct.mit.edu/books/oa-monograph/2320/Gaussian-Processes-for-Machine-Learning>Rasmussen and Williams (2005)</a>. I thank the authors for publishing openly without charge.
My own work in implementing sparse Gaussian Processes for signal to noise estimation for binary black hole merger detectability with a single LIGO detector is briefly summarized in Appendix A of <a href=https://journals.aps.org/prd/abstract/10.1103/PhysRevD.108.043023 target="_blank">Delfavero et al. (2023)</a>.
I would like to acknowledge the work done by <a href=https://www.sciencedirect.com/science/article/abs/pii/S0020025525004384 target="_blank">Esmaeilbeigi et al. (2025)</a> for putting the advantages and limitations of the Wenland kernel that I have stumbled through in practical implementations into the vocabulary of higher mathematics.
I would also like to thank Nicolas Posner, who has accompanied my introduction to rust, and whose <a href=https://nrposner.com/ target="_blank">blog</a> and contributions to other modules encouraged me to learn Rust.
I would also like to thank Nick Fotopoulos for a thorough and constructive code review of the Rust crate!
| text/markdown | null | "V. Delfavero" <xevra86@gmail.com> | null | "V. Delfavero" <xevra86@gmail.com> | BSD 3-Clause License | gaussian-process, information analysis, machine learning, kernel | [
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3",
"Operating System :: OS Independent",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Information Analysis"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"numpy<2.4.0,>=2.0.0",
"h5py>=2.7.0",
"matplotlib>=2.0.0"
] | [] | [] | [] | [
"Homepage, https://gitlab.com/xevra/csrk-py",
"Bug tracker, https://gitlab.com/xevra/csrk-py/issues"
] | twine/6.2.0 CPython/3.12.12 | 2026-02-20T17:40:43.277606 | csrk-0.1.4.tar.gz | 1,218,235 | 5e/cc/945fffb25246b5a3f070c96215d9c8918ac1c8935b3c5fa3f1eaf88144a8/csrk-0.1.4.tar.gz | source | sdist | null | false | a1db5eb11eff87e76ba62cf3c2f7c695 | c038df9cc09ca56ab8c0b9621af27fef2a3fb094d77dd9a2b9ca373bcdf363a8 | 5ecc945fffb25246b5a3f070c96215d9c8918ac1c8935b3c5fa3f1eaf88144a8 | null | [] | 108 |
2.4 | sutras | 0.4.0 | Devtool for creating, testing, and distributing Anthropic Agent Skills with lifecycle management, Skill ABI, and federated registries | # Sutras
**Devtool for Anthropic Agent Skills with lifecycle management.**
Sutras is a CLI tool and library for creating, validating, and managing [Anthropic Agent Skills](https://platform.claude.com/docs/en/agent-sdk/skills). It provides scaffolding, validation, and a standardized Skill ABI for better skill organization and quality.
[](https://pypi.org/project/sutras/)
[](https://pypi.org/project/sutras/)
[](https://github.com/anistark/sutras)
[](https://opensource.org/licenses/MIT)
## Key Features
- **Scaffold**: Generate skills with proper structure and best-practice templates
- **Validate**: Check skill format, metadata, and quality standards
- **Discover**: List and inspect available skills in your workspace
- **Manage**: Organize skills with versioning and metadata
- **Test & Evaluate**: Run tests and evaluate skills with metrics
- **Package**: Build distributable tarballs with checksums
- **Distribute**: Publish and install skills from federated Git-based registries
- **Integrations**: First-class support for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and [pi](https://github.com/badlogic/pi)
## Why Sutras?
Creating Anthropic Skills manually requires:
- Writing SKILL.md files with correct YAML frontmatter
- Managing metadata and descriptions
- Ensuring consistent structure
- Validating format and quality
Sutras automates this with simple CLI commands.
## Installation
```sh
pip install sutras
```
Or with uv:
```sh
uv pip install sutras
```
### Claude Code Integration
Install the sutras skill so Claude Code can create and manage skills:
```sh
sutras setup
```
### Pi Integration
[](https://www.npmjs.com/package/sutras)
[](https://www.npmjs.com/package/sutras)
Install the sutras extension for pi (provides `/sutras` commands):
```sh
pi install npm:sutras
```
## Quick Start
### Create a New Skill
```sh
sutras new my-skill --description "What this skill does and when to use it"
```
This creates:
```sh
.claude/skills/my-skill/
├── SKILL.md # Skill definition with YAML frontmatter
├── sutras.yaml # Metadata (version, author, tests, etc.)
└── examples.md # Usage examples
```
### List Skills
```sh
sutras list
```
### View Skill Details
```sh
sutras info my-skill
```
### Validate a Skill
```sh
sutras validate my-skill
# Strict mode (warnings become errors)
sutras validate my-skill --strict
```
## CLI Reference
### Skill Development
```sh
# Create a new skill
sutras new <name> [--description TEXT] [--author TEXT] [--global]
# List skills
sutras list [--local/--no-local] [--global/--no-global]
# Show skill details
sutras info <name>
# Validate skill
sutras validate <name> [--strict]
# Run tests
sutras test <name> [--verbose] [--fail-fast]
# Evaluate with metrics
sutras eval <name> [--verbose] [--no-history] [--show-history]
```
### Setup & Integrations
```sh
# Install sutras skill into Claude Code
sutras setup
# Check what would be installed
sutras setup --check
# Remove the skill from Claude Code
sutras setup --uninstall
```
### Distribution
```sh
# Build distributable package
sutras build <name> [--output PATH] [--no-validate]
# Publish to registry
sutras publish [PATH] [--registry NAME] [--pr]
# Install from various sources
sutras install <SOURCE> [--version VERSION] [--registry NAME]
# SOURCE can be:
# @namespace/skill-name - From registry
# github:user/repo@version - From GitHub release
# https://example.com/skill.tar.gz - From URL
# ./skill.tar.gz - From local file
# Uninstall skill
sutras uninstall <skill-name> [--version VERSION]
```
### Registry Management
```sh
# Add a registry
sutras registry add <name> <git-url> [--namespace NS] [--priority N] [--default]
# List registries
sutras registry list
# Remove registry
sutras registry remove <name>
# Update registry index
sutras registry update <name>
sutras registry update --all
# Build index for local registry
sutras registry build-index <path> [--output PATH]
```
### Package and Distribute
#### Building Packages
```sh
# Build a distributable package
sutras build my-skill
# Build with custom output directory
sutras build my-skill --output ./packages
# Skip validation
sutras build my-skill --no-validate
```
Creates a versioned tarball (e.g., `my-skill-1.0.0.tar.gz`) in `dist/` containing:
- SKILL.md and sutras.yaml
- Supporting files (examples.md, etc.)
- MANIFEST.json with checksums and metadata
**Requirements for distribution:**
- Version (semver format) in sutras.yaml
- Author in sutras.yaml
- License in sutras.yaml
- Valid skill name and description
- Scoped name format: `@namespace/skill-name` (required for registry publishing)
#### Publishing to Registry
```sh
# Publish to default registry
sutras publish
# Publish to specific registry
sutras publish --registry my-registry
# Use pull request workflow (for public registries)
sutras publish --pr
```
**Publishing requirements:**
- All build requirements above
- Skill name must be scoped: `@username/skill-name`
- Registry must be configured with write access (or use --pr flag)
#### Installing Skills
Skills can be installed from multiple sources:
**From Registry:**
```sh
# Install latest version from any configured registry
sutras install @username/skill-name
# Install specific version
sutras install @username/skill-name --version 1.2.0
# Install from specific registry
sutras install @username/skill-name --registry company-registry
```
**From GitHub Releases:**
```sh
# Install latest release
sutras install github:username/repo
# Install specific version
sutras install github:username/repo@v1.0.0
sutras install github:username/repo@1.0.0
```
**From Direct URL:**
```sh
# Install from any HTTPS URL
sutras install https://example.com/skills/my-skill-1.0.0.tar.gz
sutras install https://github.com/user/repo/releases/download/v1.0.0/skill.tar.gz
```
**From Local File:**
```sh
# Install from local tarball
sutras install ./dist/my-skill-1.0.0.tar.gz
sutras install /path/to/skill.tar.gz
```
Installed skills are placed in:
- `~/.claude/installed/` - Versioned skill installations
- `~/.claude/skills/` - Symlinks to active versions
**Note:** GitHub releases and direct URL installs allow sharing skills without setting up a registry!
#### Registry Setup
```sh
# Add the official registry (example)
sutras registry add official https://github.com/anthropics/sutras-registry --default
# Add a company registry
sutras registry add company https://github.com/mycompany/skills-registry --priority 10
# Add a personal registry
sutras registry add personal https://github.com/myuser/my-skills
# Update all registry indexes
sutras registry update --all
```
**Registry features:**
- Federated Git-based design (like Homebrew taps, Go modules)
- No central infrastructure required
- Private registries via Git authentication
- Works offline with cached indexes
- Multiple registry support with priority ordering
## Skill Structure
Every skill contains:
### SKILL.md (required)
Standard Anthropic Skills format with YAML frontmatter:
```yaml
---
name: my-skill
description: What it does and when Claude should use it
allowed-tools: Read, Write # Optional
---
# My Skill
Instructions for Claude on how to use this skill...
```
### sutras.yaml (recommended)
Extended metadata for lifecycle management:
```yaml
version: "1.0.0"
author: "Your Name"
license: "MIT"
capabilities:
tools: [Read, Write]
dependencies:
- name: "@utils/common"
version: "^1.0.0"
- "@tools/formatter" # shorthand, any version
distribution:
tags: ["automation", "pdf"]
category: "document-processing"
```
### Dependency Version Constraints
Sutras supports npm-style semver constraints:
- **Exact**: `1.0.0` - Only version 1.0.0
- **Caret**: `^1.0.0` - Compatible with 1.x.x (>=1.0.0 <2.0.0)
- **Tilde**: `~1.2.3` - Compatible with 1.2.x (>=1.2.3 <1.3.0)
- **Ranges**: `>=1.0.0 <2.0.0` - Explicit version ranges
- **Wildcards**: `1.x`, `1.2.x`, `*` - Any matching version
### Lock Files
When dependencies are resolved, Sutras creates a `.sutras.lock` file that pins exact versions for reproducible installations. This file should be committed to version control.
### Supporting Files (optional)
- `examples.md` - Usage examples
- Additional resources as needed
## Skill Locations
Skills are stored in:
- **Project**: `.claude/skills/` (shared via git)
- **Global**: `~/.claude/skills/` (personal only)
Use `--global` flag with `sutras new` to create global skills.
## Library Usage
```python
from sutras import SkillLoader
loader = SkillLoader()
skills = loader.discover() # Find all skills
skill = loader.load("my-skill") # Load specific skill
print(skill.name)
print(skill.description)
print(skill.version)
```
## Examples
See [examples/skills/](./examples/skills/) for sample skills demonstrating best practices.
## Contributing
Contributions welcome! See [CONTRIBUTING.md](./CONTRIBUTING.md) for:
- Development setup
- Code style guidelines
- Testing requirements
- PR process
#### [MIT LICENSE](./LICENSE)
| text/markdown | null | Kumar Anirudha <oss@anirudha.dev> | null | null | MIT | agent, ai, anthropic, cli, devtools, packaging, registry, skills | [
"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",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"click>=8.0.0",
"jinja2>=3.0.0",
"pydantic>=2.0.0",
"pyyaml>=6.0",
"myst-parser>=4.0.0; extra == \"docs\"",
"sphinx-autobuild>=2024.10.0; extra == \"docs\"",
"sphinx<9,>=8.1.0; extra == \"docs\"",
"sphinxawesome-theme>=5.3.2; extra == \"docs\"",
"ragas>=0.4.3; extra == \"eval\""
] | [] | [] | [] | [
"Homepage, https://anistark.github.io/sutras/",
"Documentation, https://anistark.github.io/sutras/",
"Repository, https://github.com/anistark/sutras"
] | uv/0.7.8 | 2026-02-20T17:39:41.973256 | sutras-0.4.0.tar.gz | 55,775 | f9/32/905c58ba37887725b52915a9ba8915f5b495fa94a74cb4c9e8f51f27fb03/sutras-0.4.0.tar.gz | source | sdist | null | false | 7c59c5b0b80a44b32a4a9583ddc74342 | e86b9f61598bb0a80fdf37f69fa38a3cd2301b361ccb821b38789296abcd0fd5 | f932905c58ba37887725b52915a9ba8915f5b495fa94a74cb4c9e8f51f27fb03 | null | [
"LICENSE"
] | 166 |
2.4 | a2a-market-sdk | 0.1.1 | Python SDK for the Agent-to-Agent Marketplace — post tasks, claim work, get paid in USDC | # a2a-market-sdk — Python SDK for agentsmesh.xyz
The official Python SDK for the [A2A Marketplace](https://agentsmesh.xyz) — where AI agents post tasks, claim work, and get paid in USDC via smart contract escrow.
## Install
```bash
pip install a2a-market-sdk
```
## Quickstart
```python
from a2a import A2AClient, TaskStatus
client = A2AClient(
api_url="https://a2a-market-production.up.railway.app",
api_key="your-api-key",
agent_id="your-agent-id",
)
# Register your agent (first time only)
# Do this via the API directly: POST /v1/agents/register
# List open tasks
tasks = client.list_tasks(status=TaskStatus.OPEN)
# Claim a task
client.claim_task(task_id=tasks[0].task_id)
# Submit result (result must be a dict)
client.submit_result(
task_id=tasks[0].task_id,
result={"output": "Done — here is the output...", "confidence": 1.0}
)
```
## Features
- Post and claim tasks with USDC rewards
- Smart contract escrow via A2AEscrow on Base Mainnet
- SSE streaming for real-time task updates
- Full async support via aiohttp
- Pydantic models for type safety
## Contract
A2AEscrow deployed on Base Mainnet: `0xB59de250f19a39FC051adAaCDB8147CF70ebE9FF`
## Links
- Marketplace: https://agentsmesh.xyz
- API: https://a2a-market-production.up.railway.app
- Repo: https://github.com/x4v13r1120/a2a-market
| text/markdown | Mig & Bertha | Mig & Bertha <agents@redgoats.ai> | null | null | MIT | agent, a2a, marketplace, ai, tasks, usdc, escrow | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"requests>=2.28.0",
"pydantic>=2.0",
"aiohttp>=3.8.0",
"web3>=6.0.0"
] | [] | [] | [] | [
"Homepage, https://agentsmesh.xyz",
"Repository, https://github.com/x4v13r1120/a2a-market",
"Documentation, https://agentsmesh.xyz"
] | twine/6.2.0 CPython/3.12.6 | 2026-02-20T17:39:36.497033 | a2a_market_sdk-0.1.1.tar.gz | 5,840 | 50/86/220e4f8cd46f6b17d77ed9d04a868efabe4a91f2b9508e14eee964f4e468/a2a_market_sdk-0.1.1.tar.gz | source | sdist | null | false | 42e2c787d91e21678a26fd62019cefd3 | a4f66a13f13d7877049b1a944ee18e678e6ceccef85490ea0c2416af25f523bd | 5086220e4f8cd46f6b17d77ed9d04a868efabe4a91f2b9508e14eee964f4e468 | null | [] | 182 |
2.4 | mana-bar | 0.1.17 | A task flow management tool for syncing todo files with taskwarrior | # Mana-bar (法力槽)
Mana-bar 是一个基于命令行的任务流管理工具，旨在帮助你管理不同项目的“精力”或“疲劳值”。通过设定每个项目的疲劳上限和消耗速率，你可以更好地规划和追踪你的工作状态，避免过度劳累。
## 简介
在日常工作中，我们往往会在多个项目之间切换。Mana-bar 引入了“法力值”（Mana）或“疲劳值”的概念：
- 每个项目都有一个**疲劳上限**（Total Fatigue）。
- 当你开始在一个项目上工作时，疲劳值会随着时间积累。
- 不同的项目可以设置不同的**消耗速率**（Rate）。
- 当疲劳值达到上限时，意味着你需要休息或切换到其他项目。
- 疲劳值会随着时间的推移（休息）通过某种机制恢复（当前代码逻辑主要关注记录和显示）。
## 安装
确保你已经安装了 Python 3.10+。
```bash
git clone <repository_url>
cd Mana-bar
pip install .
```
或者使用 `pip` 安装依赖：
```bash
pip install -e .
```
## 使用说明
安装完成后，你可以使用 `mana` 命令来管理你的任务。
### 1. 添加项目 (Add)
开始管理一个新项目之前，你需要先添加它，并设置其疲劳上限和消耗速率。
```bash
mana add <project_name> --total <total_fatigue> --rate <fatigue_rate>
```
- `<project_name>`: 项目名称。
- `--total`, `-t`: 疲劳值上限，默认 156。
- `--rate`, `-r`: 疲劳消耗速率，默认 1.0。
示例：
```bash
mana add coding -t 200 -r 1.5
```
### 2. 开始任务 (Open)
开始在一个项目上工作。
```bash
mana open <project_name> [--task <task_desc>] [--extra <extra_id>]
```
- `<project_name>`: 项目名称。
- `--task`, `-t`: (可选) 任务描述。
- `--extra`, `-e`: (可选) 额外ID。
示例：
```bash
mana open coding -t "Implement README"
```
### 3. 结束任务 (Close)
停止当前项目的计时。
```bash
mana close <project_name>
```
示例：
```bash
mana close coding
```
### 4. 查看项目状态 (Check)
查看指定项目的当前疲劳值状态。
```bash
mana check <project_name>
```
输出将显示一个进度条，指示当前的精力和疲劳状态。
### 5. 查看所有项目 (Checkall)
查看所有项目的状态。
```bash
mana checkall
```
## 开发
本项目使用 [Typer](https://typer.tiangolo.com/) 构建 CLI，使用 [Rich](https://github.com/Textualize/rich) 进行终端美化。
### 依赖安装
```bash
pip install -r requirements.txt
# 或者
pip install .[dev]
```
### 运行测试
```bash
pytest
```
## License
[MIT License](LICENSE)
| text/markdown | null | Your Name <your.email@example.com> | null | null | null | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"typer>=0.9.0",
"rich",
"typing_extensions",
"pytest>=7.0.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T17:39:06.093899 | mana_bar-0.1.17.tar.gz | 8,984 | ce/70/39f1d25a728a6d29a771d2c8e813639e92d52d294bda4a23a26f47d9e463/mana_bar-0.1.17.tar.gz | source | sdist | null | false | 16b44404988237da9f320eaf3166c771 | 4b04be06a3d95d606ac990df6d87fc700e3705a465c9b4e67fa631d92041da9b | ce7039f1d25a728a6d29a771d2c8e813639e92d52d294bda4a23a26f47d9e463 | null | [] | 174 |
2.4 | foundry-mcp | 0.12.0b27 | MCP server for spec-driven development management | # foundry-mcp
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://modelcontextprotocol.io/)
[](https://pypi.org/project/foundry-mcp/)
**Turn AI coding assistants into reliable software engineers with structured specs, progress tracking, and automated review.**
## Table of Contents
- [Why foundry-mcp?](#why-foundry-mcp)
- [Key Features](#key-features)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [How It Works](#how-it-works)
- [Configuration](#configuration)
- [Advanced Usage](#advanced-usage)
- [Documentation](#documentation)
- [Scope and Limitations](#scope-and-limitations)
- [Testing](#testing)
- [Contributing](#contributing)
- [License](#license)
## Why foundry-mcp?
**The problem:** AI coding assistants are powerful but unreliable on complex tasks. They lose context mid-feature, skip steps without warning, and deliver inconsistent results across sessions.
**The solution:** foundry-mcp provides the scaffolding to break work into specs, track progress, and verify outputs—so your AI assistant delivers like a professional engineer.
- **No more lost context** — Specs persist state across sessions so the AI picks up where it left off.
- **No more skipped steps** — Task dependencies and blockers ensure nothing gets missed.
- **No more guessing progress** — See exactly what's done, what's blocked, and what's next.
- **No more manual review** — AI review validates implementation against spec requirements.
## Key Features
- **Specs keep AI on track** — Break complex work into phases and tasks the AI can complete without losing context.
- **Progress you can see** — Track what's done, what's blocked, and what's next across multi-session work.
- **AI-powered review** — LLM integration reviews specs, generates PR descriptions, and validates implementation.
- **Works with your tools** — Runs as MCP server (Claude Code, Gemini CLI) or standalone CLI with JSON output.
- **Security built in** — Workspace scoping, API key auth, rate limits, and audit logging ship by default.
- **Discovery-first** — Capabilities declared in a manifest so clients negotiate features automatically.
## Installation
### Prerequisites
- Python 3.10 or higher
- macOS, Linux, or Windows
- MCP-compatible client (e.g., Claude Code)
### Install with uvx (recommended)
```bash
uvx foundry-mcp
```
### Install with pip
```bash
pip install foundry-mcp
```
### Install from source (development)
```bash
git clone https://github.com/tylerburleigh/foundry-mcp.git
cd foundry-mcp
pip install -e ".[test]"
```
## Quick Start
**1. Install the claude-foundry plugin** (from within Claude Code):
```
/plugin marketplace add foundry-works/claude-foundry
/plugin install foundry@claude-foundry
```
Restart Claude Code and trust the repository when prompted.
> **Note:** The plugin automatically registers the MCP server using `uvx` — no separate installation needed.
**2. Run setup:**
```
Please run foundry-setup to configure the workspace.
```
**3. Start building:**
```
I want to add user authentication with JWT tokens.
```
Claude creates a spec with phases, tasks, and verification steps. Ask to implement and it works through tasks in dependency order.
## How It Works
foundry-mcp is the **MCP server** that provides the underlying tools and APIs. The [claude-foundry](https://github.com/foundry-works/claude-foundry) plugin provides the **user-facing skills** that orchestrate workflows.
```
You → Claude Code → claude-foundry plugin → foundry-mcp server
│ │ │
▼ ▼ ▼
Natural Skills like MCP tools for
language foundry-spec, specs, tasks,
requests foundry-implement reviews, etc.
```
| Component | Role |
|-----------|------|
| **foundry-mcp** | MCP server + CLI providing spec/task/review tools |
| **claude-foundry** | Claude Code plugin providing skills and workflow |
For most users, install both and interact through natural language. The plugin handles tool orchestration automatically.
## Configuration
### API Keys
foundry-mcp uses LLM providers for AI-powered features like spec review, consensus, and deep research. Set the API keys for providers you want to use:
```bash
# AI CLI tools (for AI review, consensus)
export CLAUDE_CODE_OAUTH_TOKEN="..." # Get via: claude setup-token
export GEMINI_API_KEY="..."
export OPENAI_API_KEY="sk-..."
export CURSOR_API_KEY="key-..."
# Deep research providers (for /foundry-research deep workflow)
export TAVILY_API_KEY="..."
export PERPLEXITY_API_KEY="..."
```
### TOML Configuration (Optional)
Configuration loads in layers (later layers override earlier):
1. **User config** (`~/.foundry-mcp.toml`) - User-wide defaults for API keys, preferred providers
2. **Project config** (`./foundry-mcp.toml`) - Project-specific settings
```bash
# For user-wide settings (API keys, provider preferences)
cp samples/home-foundry-mcp.toml ~/.foundry-mcp.toml
# For project-specific settings
cp samples/foundry-mcp.toml ./foundry-mcp.toml
```
## Advanced Usage
### Direct MCP Configuration (without plugin)
For MCP clients other than Claude Code, or if you prefer manual configuration:
```json
{
"mcpServers": {
"foundry-mcp": {
"command": "uvx",
"args": ["foundry-mcp"],
"env": {
"FOUNDRY_MCP_SPECS_DIR": "/path/to/specs"
}
}
}
}
```
<details>
<summary>Using a pip installation instead?</summary>
```json
{
"mcpServers": {
"foundry-mcp": {
"command": "foundry-mcp",
"env": {
"FOUNDRY_MCP_SPECS_DIR": "/path/to/specs"
}
}
}
}
```
</details>
### CLI Usage
All MCP tools are also available via CLI with JSON output:
```bash
# Get next task to work on
python -m foundry_mcp.cli task next --specs-dir ./specs
# Validate a spec
python -m foundry_mcp.cli spec validate my-feature-001
# Create a new spec
python -m foundry_mcp.cli authoring create --name "my-feature" --template detailed
```
### Launch as Standalone MCP Server
```bash
foundry-mcp
```
The server advertises its capabilities, feature flags, and response contract so MCP clients (Claude Code, Gemini CLI, etc.) can connect automatically.
## Documentation
### User guides
| Guide | Description |
|-------|-------------|
| [Quick Start](docs/01-quick-start.md) | Get up and running in 5 minutes |
| [Core Concepts](docs/02-core-concepts.md) | Understand specs, phases, and tasks |
| [Workflow Guide](docs/03-workflow-guide.md) | End-to-end development workflows |
| [CLI Reference](docs/04-cli-command-reference.md) | Complete CLI command documentation |
| [MCP Tool Reference](docs/05-mcp-tool-reference.md) | All MCP tools and their parameters |
| [Configuration](docs/06-configuration.md) | Environment variables and TOML setup |
| [Troubleshooting](docs/07-troubleshooting.md) | Common issues and solutions |
### Concepts
| Guide | Description |
|-------|-------------|
| [Foundry Philosophy](docs/concepts/foundry-philosophy.md) | Why spec-driven development matters |
| [Response Envelope](docs/concepts/response-envelope.md) | Standardized response format |
| [Spec Schema](docs/concepts/spec-schema.md) | Spec file structure and fields |
| [LLM Configuration](docs/guides/llm-configuration.md) | Provider setup and fallbacks |
### Developer docs
| Guide | Description |
|-------|-------------|
| [Dev Docs Index](dev_docs/README.md) | Entry point for developer documentation |
| [MCP Best Practices](dev_docs/mcp_best_practices/README.md) | Canonical implementation checklist |
| [Response Schema](dev_docs/codebase_standards/mcp_response_schema.md) | Standardized envelope reference |
| [CLI Output Contract](dev_docs/codebase_standards/cli-output.md) | JSON-first CLI expectations |
## Scope and Limitations
**Best for:**
- Multi-step feature development with AI assistants
- Teams wanting structured handoff between AI and human reviewers
- Projects requiring audit trails and progress visibility
**Not suited for:**
- Quick one-off code changes (use your AI assistant directly)
- Non-software tasks (specs are code-focused)
- Fully autonomous AI agents (foundry assumes human oversight)
## Testing
```bash
pytest # Full suite
pytest tests/integration/test_mcp_smoke.py # MCP smoke tests
pytest tests/integration/test_mcp_tools.py # Tool contract coverage
```
- Regression tests keep MCP/CLI adapters aligned across surfaces.
- Golden fixtures (`tests/fixtures/golden`) ensure response envelopes, error semantics, and pagination never regress.
- Freshness checks run alongside core unit and integration suites.
## Contributing
Contributions are welcome! Please read the [MCP Best Practices](dev_docs/mcp_best_practices/README.md) before submitting PRs. All changes should keep specs, docs, code, and fixtures in sync.
## License
MIT License — see [LICENSE](LICENSE) for details.
---
**Built by [Tyler Burleigh](https://github.com/tylerburleigh)** · [Report an Issue](https://github.com/tylerburleigh/foundry-mcp/issues) · [View on GitHub](https://github.com/tylerburleigh/foundry-mcp)
| text/markdown | Tyler Burleigh | null | null | null | null | foundry, mcp, spec-driven-development, specification | [
"Development Status :: 3 - Alpha",
"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"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"click>=8.0.0",
"fastmcp>=0.1.0",
"filelock>=3.20.1",
"mcp>=1.0.0",
"python-ulid>=2.0.0",
"rich>=13.0.0",
"tomli>=2.0.0; python_version < \"3.11\"",
"hypothesis>=6.0.0; extra == \"dev\"",
"jsonschema>=4.0.0; extra == \"dev\"",
"pyright>=1.1.390; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest-xdist>=3.0.0; extra == \"dev\"",
"pytest>=7.0.0; extra == \"dev\"",
"ruff<0.10,>=0.9.0; extra == \"dev\"",
"prometheus-client>=0.17.0; extra == \"metrics\"",
"opentelemetry-exporter-otlp>=1.20.0; extra == \"observability\"",
"opentelemetry-sdk>=1.20.0; extra == \"observability\"",
"prometheus-client>=0.17.0; extra == \"observability\"",
"pdfminer-six>=20221105; extra == \"pdf\"",
"pypdf>=5.0.0; extra == \"pdf\"",
"hypothesis>=6.0.0; extra == \"test\"",
"jsonschema>=4.0.0; extra == \"test\"",
"pytest-asyncio>=0.21.0; extra == \"test\"",
"pytest-xdist>=3.0.0; extra == \"test\"",
"pytest>=7.0.0; extra == \"test\"",
"opentelemetry-exporter-otlp>=1.20.0; extra == \"tracing\"",
"opentelemetry-sdk>=1.20.0; extra == \"tracing\""
] | [] | [] | [] | [
"Homepage, https://github.com/tylerburleigh/foundry-mcp",
"Repository, https://github.com/tylerburleigh/foundry-mcp"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:39:01.258616 | foundry_mcp-0.12.0b27.tar.gz | 2,360,840 | c3/4c/ba9f73e44429bcaa78712a439a394aa3df6cd1c1f27cb09dd5e58c71b0a4/foundry_mcp-0.12.0b27.tar.gz | source | sdist | null | false | ffe3c011f08cb9bbc905fd2190d5314d | 7194a66394971c9081e32d5b41c899e214485e7200a1f7272b6939b3f1886ed6 | c34cba9f73e44429bcaa78712a439a394aa3df6cd1c1f27cb09dd5e58c71b0a4 | MIT | [
"LICENSE"
] | 152 |
2.4 | thorpy | 2.1.14 | GUI library for pygame | ThorPy is a non-intrusive, straightforward GUI kit for Pygame.
| text/plain | Yann Thorimbert | yann.thorimbert@gmail.com | null | null | MIT | pygame, gui, menus, buttons, widgets, user interface, toolkit | [] | [] | http://www.thorpy.org/ | null | null | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.2 | 2026-02-20T17:38:32.515769 | thorpy-2.1.14.tar.gz | 2,113,081 | 5c/2a/74cb6ac401a1cc71ed04a1b570ad73989a8f15d38830163b8167139b7038/thorpy-2.1.14.tar.gz | source | sdist | null | false | ec3186faef82f14fe5ee2792389d2a7b | 973e4c9c479cb2cda4c3c385640958260def6d3bb12a8d85599307a0264a083a | 5c2a74cb6ac401a1cc71ed04a1b570ad73989a8f15d38830163b8167139b7038 | null | [] | 203 |
2.4 | generate-project | 1.3.0 | A Python project generator using cookiecutter templates | [](https://opensource.org/licenses/MIT)
[](https://pypi.org/project/generate-project/)
[](https://www.python.org/downloads/release/python-3100/)
[](https://generate-project.readthedocs.io/en/latest/?badge=latest)
# Generate Project
A Python project folder generator with support for **Poetry** and **UV** package managers. The generated folder provides everything you need to get started with a well-structured Python project, including development tasks for formatting, linting, documentation, testing, and CI/CD.
## Features
📦 Poetry or UV for dependency management and packaging
🧹 Code quality tools including black, isort, flake8, mypy and pylint
📚 Sphinx based documentation with auto-generated API docs and live preview
✅ Testing framework with pytest and test coverage reports
🔄 GitHub actions with CI/CD workflows for tests, documentation and release management
🐍 PyPl package publishing automation with version control
📝 ReadTheDocs integration for hosting documentation
🚀 Automated release process for versioning and publishing
📋 Project structure following best practices
## Requirements
Python 3.10+
Cookiecutter 2.6.0+
PyYAML 6.0.0+
python-dotenv 1.1.0+
## Installation
```bash
pip install generate-project
```
Or, if you use Poetry:
```bash
poetry add generate-project
```
Or, if you use UV:
```bash
uv add generate-project
```
## Quick Start
### Basic Usage
You can provide the project configuration values in the terminal command line:
```bash
generate-project generate "project-name" \
--author_name="Your Name" \
--email="your.email@example.com" \
--github_username="yourusername" \
--python_min_version="3.11"
...
```
### Project Configuration Options
These are the most important project configuration options:
| Option | Description |
|--------|-------------|
| `package_name` | Python package name (defaults to project_name)|
| `author_name` | Author's name |
| `email` | Author's email |
| `github_username` | GitHub username |
| `version` | Initial version number |
| `description` | Short project description |
| `python_min_version` | Minimum Python version |
### Advanced Usage
You can also save your own configuration values to be used as default values:
```bash
generate-project config \
--author_name="Your Name" \
--email="your.email@example.com" \
--github_username="yourusername" \
--python_min_version="3.11"
```
You can also set the default package manager:
```bash
generate-project config --manager uv
```
and then you can omit the saved configuration options:
```bash
generate-project generate "project-name"
...
```
## Package Manager
By default, generate-project creates projects using **Poetry**. Use the `--manager` flag to select **UV** instead:
| Manager | Build Backend | Dependency Format | Command |
|---------|--------------|-------------------|---------|
| Poetry (default) | poetry-core | `[tool.poetry.dependencies]` | `--manager poetry` |
| UV | hatchling | `[dependency-groups]` (PEP 735) | `--manager uv` |
```bash
# Poetry project (default)
generate-project generate my-project
# UV project
generate-project generate my-project --manager uv
```
## Project Structure
The generated project will have the following structure:
```
project-name/
├── .github/workflows/ # GitHub actions for CI/CD
│ ├── docs.yml # Documentation building and testing
│ ├── tests.yml # Code quality and testing
│ ├── release.yml # Automated releases and publishing
│ └── update_rtd.yml # Manual ReadTheDocs updates
├── .vscode/ # VS Code configuration
│ ├── settings.json # Editor settings, linting, formatting
│ ├── launch.json # Debug configurations
│ └── tasks.json # Task definitions
├── docs/ # Sphinx documentation
│ ├── api/ # Auto-generated API docs
│ ├── guides/ # User guides
│ ├── conf.py # Sphinx configuration
│ └── index.md # Documentation home
├── src/package_name/ # Source code
│ └── __init__.py # Package initialization
├── tests/ # Test directory
├── scripts/ # Release management scripts
├── .env # Environment variables (if --local-env used)
├── .gitignore # Git ignore rules
├── .readthedocs.yaml # ReadTheDocs configuration
├── CLAUDE.md # Claude Code integration guide
├── CredentialManagement.md # Token management documentation
├── LICENSE # MIT License
├── Makefile # Development commands
├── pyproject.toml # Project configuration
├── run.sh # Development task runner
└── README.md # Project documentation
```
## Project Types
By default, generate-project creates an **application** project with a CLI entry point. Use the `--library` flag to create a library project instead:
```bash
# Create an application (default)
generate-project generate my-app
# Create a library
generate-project generate my-lib --library
```
| Project Type | CLI Entry Point | main.py | Use Case |
|--------------|-----------------|---------|----------|
| Application | Yes | Yes | CLI tools, scripts |
| Library | No | No | Reusable packages, APIs |
## GitHub Repository Setup
The following options are available to setup a github repository for the project:
| Option | Description |
|--------|-------------|
| `--github` | Create a private github repository for the project |
| `--public` | Create a public github repository for the project|
| `--secrets` | Create repository secrets for the release management workflows |
The following repository secrets can be automatically setup:
`TEST_PYPI_TOKEN`
`PYPI_TOKEN`
`RTD_TOKEN`
The tokens must be available in a .env file located in the directory where generate-project is executed or in any parent directory up the folder hierarchy. If no .env file is found, the application falls back to reading the tokens from environment variables.
## Development Workflow
The generated project includes a Makefile with common development tasks:
```bash
# Environment Setup
make venv # Create and activate a local virtual environment
make install # Install core dependencies
make install-dev # Install all development dependencies
# Code quality
make format # Run code formatters
make lint # Run linters
make check # Run format + lint + tests on all files
make pre-commit # Run format and lint only on changed files, then tests
# Testing
make test # Run tests
make test-cov # Run tests with coverage
make coverage # Generate coverage report
# Documentation
make docs-api # Generate API documentation
make docs # Build documentation
make docs-live # Start live preview server
# Release tasks will bump the version, create a new release and publish it
make release-major # Create major release
make release-minor # Create minor release
make release-micro # Create micro (patch) release
make release-rc # Create release candidate
make release-beta # Create beta pre-release
make release-alpha # Create alpha pre-release
```
Run `make help` for a complete list of the development tasks available.
## Acknowledgments
This project was inspired by the GitHub workflows and automation ideas
from [phitoduck/python-course-cookiecutter-v2](https://github.com/phitoduck/python-course-cookiecutter-v2).
While this project is an independent implementation and a full Python
application, the original repository provided valuable inspiration for
the CI/CD and automation approach.
We thank the original authors for their contributions and ideas.
## License
This project is released under the MIT License. See the LICENSE file for details.
| text/markdown | Antonio Pisani | antonio.pisani@gmail.com | null | null | null | python, project-generator, cookiecutter, template | [
"Development Status :: 5 - Production/Stable",
"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",
"Topic :: Software Development :: Code Generators"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"cookiecutter>=2.6.0",
"python-dotenv>=1.1.0",
"pyyaml>=6.0.0"
] | [] | [] | [] | [
"Documentation, https://generate-project.readthedocs.io/",
"Issue Tracker, https://github.com/apisani1/generate-project/issues",
"Release Notes, https://github.com/apisani1/generate-project/releases",
"Source Code, https://github.com/apisani1/generate-project"
] | poetry/2.3.2 CPython/3.10.19 Linux/6.11.0-1018-azure | 2026-02-20T17:38:24.431679 | generate_project-1.3.0-py3-none-any.whl | 106,827 | 3a/a7/57798b2981b97920dcbdee79f6c12bc4bb56cc8b1a7bdc3253ce7a56cca9/generate_project-1.3.0-py3-none-any.whl | py3 | bdist_wheel | null | false | 3c62aa1ee1a2301699ae920c394f674e | 8c288f1f7c6f09706933ccab19ae557c574bdee6c604a6d6d4de5fba1c778b92 | 3aa757798b2981b97920dcbdee79f6c12bc4bb56cc8b1a7bdc3253ce7a56cca9 | null | [
"LICENSE"
] | 185 |
2.4 | pelicanfs | 1.3.1 | An FSSpec Implementation using the Pelican System | # PelicanFS
[](https://zenodo.org/doi/10.5281/zenodo.13376216)
## Table of Contents
- [Overview](#overview)
- [Features](#features)
- [Limitations](#limitations)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Basic Usage](#basic-usage)
- [Using the OSDF Scheme](#using-the-osdf-scheme)
- [Object Operations](#object-operations)
- [Listing Objects and Collections](#listing-objects-and-collections)
- [Pattern Matching with Glob](#pattern-matching-with-glob)
- [Reading Objects](#reading-objects)
- [Writing Objects](#writing-objects)
- [Downloading Objects](#downloading-objects)
- [Advanced Configuration](#advanced-configuration)
- [Specifying Endpoints](#specifying-endpoints)
- [Enabling Direct Reads](#enabling-direct-reads)
- [Specifying Preferred Caches](#specifying-preferred-caches)
- [Authorization](#authorization)
- [1. Providing a Token via Headers](#1-providing-a-token-via-headers)
- [2. Environment Variables](#2-environment-variables)
- [3. Default Token Location](#3-default-token-location)
- [4. HTCondor Token Discovery](#4-htcondor-token-discovery)
- [5. OIDC Device Flow (Interactive)](#5-oidc-device-flow-interactive)
- [Token File Formats](#token-file-formats)
- [Automatic Token Discovery](#automatic-token-discovery)
- [Token Scopes](#token-scopes)
- [Token Validation](#token-validation)
- [Integration with Data Science Libraries](#integration-with-data-science-libraries)
- [Using with xarray and Zarr](#using-with-xarray-and-zarr)
- [Using with PyTorch](#using-with-pytorch)
- [Using with Pandas](#using-with-pandas)
- [Getting an FSMap](#getting-an-fsmap)
- [Monitoring and Debugging](#monitoring-and-debugging)
- [Access Statistics](#access-statistics)
- [Enabling Debug Logging](#enabling-debug-logging)
- [API Reference](#api-reference)
- [PelicanFileSystem](#pelicanfilesystem)
- [OSDFFileSystem](#osdffilesystem)
- [PelicanMap](#pelicanmap)
- [Examples](#examples)
- [Troubleshooting](#troubleshooting)
- [Contributing](#contributing)
- [License](#license)
- [Citation](#citation)
- [Support](#support)
## Overview
PelicanFS is a filesystem specification (fsspec) implementation for the Pelican Platform. It provides a Python interface to interact with Pelican federations, allowing you to read, write, and manage objects across distributed object storage systems.
For more information about Pelican, see our [main website](https://pelicanplatform.org), [documentation](https://docs.pelicanplatform.org), or [GitHub page](https://github.com/PelicanPlatform/pelican). For more information about fsspec, visit the [filesystem-spec](https://filesystem-spec.readthedocs.io/en/latest/index.html) page.
For comprehensive tutorials and real-world examples using PelicanFS with geoscience datasets, see the [Project Pythia OSDF Cookbook](https://projectpythia.org/osdf-cookbook/).
**Note on Terminology:**
- In URL terminology, `pelican://` and `osdf://` are properly called **schemes**. While fsspec refers to these as "protocols," we use the term "scheme" throughout this documentation for technical accuracy.
- Pelican works with **objects** (analogous to files) and **collections** (analogous to directories), not files and directories. Unlike traditional files, Pelican objects are immutable—once created, their content should not change without renaming, as cached copies won't automatically update. Objects also lack filesystem-specific metadata like permissions or modification timestamps. Collections are organized using namespace prefixes that function hierarchically, similar to directory structures. For more details, see the [Pelican core concepts documentation](https://docs.pelicanplatform.org/about-pelican/core-concepts).
## Features
- **Read Operations**: List, read, and search for objects across Pelican namespaces
- **Write Operations**: Upload objects to Pelican Origins with proper authorization
- **Smart Caching**: Automatic cache selection and fallback for optimal performance
- **Token Management**: Automatic token discovery and validation for authorized operations
- **OIDC Device Flow**: Interactive browser-based authentication via the Pelican CLI as a fallback when no token is found
- **Scheme Support**: Works with both `pelican://` and `osdf://` URL schemes
- **Integration**: Seamless integration with popular data science libraries (xarray, zarr, PyTorch, etc.)
- **Async Support**: Built on async foundations for efficient I/O operations
## Limitations
PelicanFS is built on top of the HTTP fsspec implementation. As such, any functionality that isn't available in the HTTP implementation is also *not* available in PelicanFS. Specifically:
- `rm` (remove objects)
- `cp` (copy objects within the federation - note that downloading objects via `get()` to local files works normally)
- `mkdir` (create collections)
- `makedirs` (create collection trees)
- `open()` with write modes (`"w"`, `"wb"`, `"a"`, `"x"`, `"+"`, etc.) - use `put()` or `pipe()` to write files instead
These operations will raise a `NotImplementedError` if called.
## Installation
To install PelicanFS from PyPI:
```bash
pip install pelicanfs
```
To install from source:
```bash
git clone https://github.com/PelicanPlatform/pelicanfs.git
cd pelicanfs
pip install -e .
```
## Quick Start
### Basic Usage
Create a `PelicanFileSystem` instance and provide it with your federation's discovery URL:
```python
from pelicanfs import PelicanFileSystem
# Connect to the OSDF federation
pelfs = PelicanFileSystem("pelican://osg-htc.org")
# List objects in a namespace
objects = pelfs.ls('/pelicanplatform/test/')
print(objects)
# Read an object
content = pelfs.cat('/pelicanplatform/test/hello-world.txt')
print(content)
```
### Using the OSDF Scheme
The Open Science Data Federation (OSDF) is a specific Pelican federation operated by the OSG Consortium. The `osdf://` scheme is a convenience shortcut that automatically connects to the OSDF federation at `osg-htc.org`, so you don't need to specify the discovery URL explicitly.
**OSDFFileSystem vs PelicanFileSystem:** `OSDFFileSystem` is similarly a convenience class that wraps `PelicanFileSystem` and automatically uses `osg-htc.org` as the discovery URL. Using `OSDFFileSystem()` is equivalent to `PelicanFileSystem("pelican://osg-htc.org")`. If you're specifically working with the OSDF federation, `OSDFFileSystem` saves you from having to specify the discovery URL. For other Pelican federations, use `PelicanFileSystem` with the appropriate discovery URL.
```python
from pelicanfs.core import OSDFFileSystem
import fsspec
# Using OSDFFileSystem (automatically connects to osg-htc.org)
osdf = OSDFFileSystem()
objects = osdf.ls('/pelicanplatform/test/')
# Or use fsspec directly with the osdf:// scheme
with fsspec.open('osdf:///pelicanplatform/test/hello-world.txt', 'r') as f:
content = f.read()
print(content)
```
## Examples
### Repository Examples
See the `examples/` directory for complete working examples:
- `examples/pelicanfs_example.ipynb` - Basic PelicanFS usage
- `examples/pytorch/` - Using PelicanFS with PyTorch for machine learning
- `examples/xarray/` - Using PelicanFS with xarray for scientific data
- `examples/intake/` - Using PelicanFS with Intake catalogs
### Project Pythia OSDF Cookbook
For comprehensive tutorials and real-world geoscience examples, see the [Project Pythia OSDF Cookbook](https://projectpythia.org/osdf-cookbook/), which includes:
- **NCAR GDEX datasets**: Meteorological, atmospheric composition, and oceanographic observations
- **FIU Envistor**: Climate datasets from south Florida
- **NOAA SONAR data**: Fisheries datasets in Zarr format
- **AWS OpenData**: Sentinel-2 satellite imagery
- **Interactive notebooks**: All examples are runnable in Binder or locally
The cookbook demonstrates streaming large scientific datasets using PelicanFS with tools like xarray, Dask, and more.
## Object Operations
### Listing Objects and Collections
**Choosing an approach:** Method 1 (using fsspec.filesystem with schemes) is recommended for most users as it works with any fsspec-compatible code and is portable across different storage backends. Method 2 (using PelicanFileSystem directly) gives you more control when you need to reuse a filesystem instance across multiple operations or access PelicanFS-specific features like getting access statistics.
```python
from pelicanfs import PelicanFileSystem
import fsspec
# Method 1: Using fsspec.filesystem() with schemes (recommended)
fs = fsspec.filesystem('osdf')
objects = fs.ls('/pelicanplatform/test/')
# List with details (size, type, etc.)
objects_detailed = fs.ls('/pelicanplatform/test/', detail=True)
# Recursively find all objects
all_objects = fs.find('/pelicanplatform/test/')
# Find objects with depth limit
objects = fs.find('/pelicanplatform/test/', maxdepth=2)
# Method 2: Using PelicanFileSystem directly (for more control)
pelfs = PelicanFileSystem("pelican://osg-htc.org")
objects = pelfs.ls('/pelicanplatform/test/')
```
### Pattern Matching with Glob
> [!WARNING]
> Glob operations with `**` patterns can be expensive for large namespaces as they recursively search through all subdirectories. Consider using `maxdepth` to limit the search depth or more specific patterns to reduce the search space.
```python
import fsspec
# Method 1: Using fsspec.filesystem() with schemes (recommended)
fs = fsspec.filesystem('osdf')
# Find all text files in the namespace
txt_objects = fs.glob('/pelicanplatform/**/*.txt')
# Find objects with depth limit
objects = fs.glob('/pelicanplatform/**/*', maxdepth=2)
# Method 2: Using PelicanFileSystem directly
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org")
txt_objects = pelfs.glob('/pelicanplatform/**/*.txt')
```
### Reading Objects
```python
import fsspec
# Method 1: Using fsspec.open with schemes (recommended)
with fsspec.open('osdf:///pelicanplatform/test/hello-world.txt', 'r') as f:
data = f.read()
print(data)
# Method 2: Using fsspec.filesystem() for cat operations
fs = fsspec.filesystem('osdf')
# Read entire object
content = fs.cat('/pelicanplatform/test/hello-world.txt')
print(content)
# Read multiple objects
contents = fs.cat(['/pelicanplatform/test/hello-world.txt',
'/pelicanplatform/test/testfile-64M'])
# Method 3: Using PelicanFileSystem directly (for more control)
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org")
content = pelfs.cat('/pelicanplatform/test/hello-world.txt')
print(content)
```
### Writing Objects
To upload local files as objects, you need proper authorization (see [Authorization](#authorization) section):
```python
# Note: Replace placeholder paths with your actual file paths, namespace, and token
import fsspec
# Method 1: Using fsspec.filesystem() with authorization (recommended)
fs = fsspec.filesystem('osdf', headers={"Authorization": "Bearer YOUR_TOKEN"})
# Upload a single file
fs.put('/local/path/file.txt', '/namespace/remote/path/object.txt')
# Upload multiple files
fs.put('/local/directory/', '/namespace/remote/path/', recursive=True)
# Method 2: Using PelicanFileSystem directly (for more control)
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org",
headers={"Authorization": "Bearer YOUR_TOKEN"})
pelfs.put('/local/path/file.txt', '/namespace/remote/path/object.txt')
```
### Downloading Objects
**Reading vs Downloading:** Reading objects (via `cat()`, `open()`) loads data into memory for processing within your Python program. Downloading objects (via `get()`) saves them as files on your local filesystem. Use `get()` when you need persistent local copies; use reading operations for direct data processing.
```python
# Note: Replace '/local/path/' and '/local/directory/' with your actual local destination paths
import fsspec
# Method 1: Using fsspec.filesystem() (recommended)
fs = fsspec.filesystem('osdf')
# Download an object to a local file
fs.get('/pelicanplatform/test/hello-world.txt', '/local/path/file.txt')
# Download multiple objects (note: no trailing slash on source path)
fs.get('/pelicanplatform/test', '/local/directory/', recursive=True)
# Method 2: Using PelicanFileSystem directly
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org")
pelfs.get('/pelicanplatform/test/hello-world.txt', '/local/path/file.txt')
```
## Advanced Configuration
### Specifying Endpoints
PelicanFS allows you to control where data is read from, rather than letting the Director automatically select the best Cache.
**Note:** The `direct_reads` and `preferred_caches` settings are mutually exclusive. If `direct_reads=True`, data will always be read from Origins and `preferred_caches` will be ignored. If `direct_reads=False` (the default), then `preferred_caches` will be used if specified.
#### Enabling Direct Reads
Read data directly from Origins, bypassing Caches entirely:
```python
pelfs = PelicanFileSystem("pelican://osg-htc.org", direct_reads=True)
```
This is useful when:
- You're physically close to the Origin server (better network latency)
- Cache performance is poor
- Your workflows don't benefit from object caching/reuse
#### Specifying Preferred Caches
Specify one or more preferred caches to use:
```python
# Note: Replace example cache URLs with actual Cache server URLs from your federation
# Use a single preferred cache
pelfs = PelicanFileSystem(
"pelican://osg-htc.org",
preferred_caches=["https://cache.example.com"]
)
# Use multiple preferred caches with fallback to Director's list
pelfs = PelicanFileSystem(
"pelican://osg-htc.org",
preferred_caches=[
"https://cache1.example.com",
"https://cache2.example.com",
"+" # Special value: append Director's caches
]
)
```
**Important:** If you specify `preferred_caches` without the `"+"` value, PelicanFS will **only** attempt to use your specified Caches and will not fall back to the Director's Cache list. This means if all your preferred Caches fail, the operation will fail rather than trying other available Caches. The Director has knowledge about Cache health, load, and availability—ignoring its recommendations means you lose these benefits.
The special Cache value `"+"` indicates that your preferred Caches should be tried first, followed by the Director's recommended Caches as a fallback.
## Authorization
PelicanFS supports token-based authorization for accessing protected namespaces and performing write operations. Tokens are used to verify that you have permission to perform operations on specific namespaces.
**To use authenticated namespaces, you must obtain a valid token from your Pelican federation administrator or token issuer and make it available through one of the discovery methods below.**
Tokens can be provided in multiple ways, checked in the following order of precedence:
### 1. Providing a Token via Headers
You can explicitly provide an authorization token when creating the filesystem:
```python
pelfs = PelicanFileSystem(
"pelican://osg-htc.org",
headers={"Authorization": "Bearer YOUR_TOKEN_HERE"}
)
```
Or when using fsspec directly:
```python
import fsspec
with fsspec.open(
'osdf:///namespace/path/file.txt',
headers={"Authorization": "Bearer YOUR_TOKEN_HERE"}
) as f:
data = f.read()
```
### 2. Environment Variables
PelicanFS will automatically discover tokens from several environment variables:
#### `BEARER_TOKEN` - Direct token value
```bash
export BEARER_TOKEN="your_token_here"
```
#### `BEARER_TOKEN_FILE` - Path to token file
```bash
export BEARER_TOKEN_FILE="/path/to/token/file"
```
#### `TOKEN` - Path to token file (legacy)
```bash
export TOKEN="/path/to/token/file"
```
### 3. Default Token Location
PelicanFS checks the default bearer token file location (typically `~/.config/htcondor/tokens.d/` or similar, depending on your system configuration).
### 4. HTCondor Token Discovery
For HTCondor environments, PelicanFS will automatically discover tokens from:
- `_CONDOR_CREDS` environment variable
- `.condor_creds` directory in the current working directory
### 5. OIDC Device Flow (Interactive)
If no valid token is found through any of the methods above, PelicanFS can interactively obtain a token using the OIDC device authorization flow. This requires the `pelican` CLI binary to be installed and available on your `PATH`.
When triggered, PelicanFS will:
1. Launch `pelican token fetch` with the appropriate URL and operation flags
2. Display a URL and device code in your terminal
3. Wait for you to authenticate in your browser
4. Extract the resulting token automatically
No extra configuration is needed — the OIDC device flow activates automatically as a last resort when no existing token is found:
```python
from pelicanfs import PelicanFileSystem
import fsspec
# Using PelicanFileSystem directly
pelfs = PelicanFileSystem("pelican://osg-htc.org")
content = pelfs.cat('/protected/namespace/file.txt')
# Using fsspec with the osdf:// scheme
with fsspec.open('osdf:///protected/namespace/file.txt', 'r') as f:
data = f.read()
# Using fsspec.filesystem()
fs = fsspec.filesystem('osdf')
content = fs.cat('/protected/namespace/file.txt')
```
When the device flow is triggered, you will see output similar to:
```
Navigate to the following URL in a browser:
https://federation.example.com/api/v1.0/auth/device?client_id=pelican-client
Enter the following code:
ABCD-EFGH
Waiting for authorization...
```
You may also be prompted for a password to encrypt or decrypt the local token file:
```
Enter a password for the token file:
```
You can configure the timeout (default 300 seconds) for the device flow:
```python
pelfs = PelicanFileSystem("pelican://osg-htc.org", oidc_timeout_seconds=600)
```
> [!NOTE]
> The OIDC device flow requires the [`pelican` CLI](https://docs.pelicanplatform.org) to be installed. If the binary is not found, PelicanFS will skip this method and raise a `NoCredentialsException`.
### Token File Formats
Token files can be in two formats:
**Plain text token:**
```
eyJhbGciOiJFUzI1NiIsImtpZCI6InhyNzZwZzJyTmNVRFNrYXVWRmlDN2owbGxvbWU4NFpsdG44RGMxM0FHVWsiLCJ0eXAiOiJKV1QifQ...
```
**JSON format:**
```json
{
"access_token": "eyJhbGciOiJFUzI1NiIsImtpZCI6InhyNzZwZzJyTmNVRFNrYXVWRmlDN2owbGxvbWU4NFpsdG44RGMxM0FHVWsiLCJ0eXAiOiJKV1QifQ...",
"expires_in": 3600
}
```
PelicanFS will automatically extract the `access_token` field from JSON-formatted token files.
### Automatic Token Discovery
When you attempt an operation that requires authorization, PelicanFS will:
1. Check if the namespace requires a token (via the Director response)
2. Search for existing tokens using the discovery methods above (in order of precedence)
3. Validate each discovered token to ensure it:
- Has not expired
- Has the correct issuer (matches the namespace's allowed issuers)
- Has the necessary scopes for the requested operation
- Is authorized for the specific namespace path
4. Use the first valid token found
5. If no valid token is found, attempt the [OIDC device flow](#5-oidc-device-flow-interactive) as a final fallback (requires the `pelican` CLI)
6. Cache the validated token for subsequent operations
This happens transparently without requiring manual token management. If no valid token is found and the OIDC device flow is unavailable or fails, the operation will fail with a `NoCredentialsException`.
### Token Scopes
PelicanFS validates that discovered tokens have the appropriate scopes for the requested operation. Pelican supports both WLCG and SciTokens2 scope formats:
- **Read operations** (`cat`, `open`, `ls`, `glob`, `find`): Require `storage.read:<path>` (WLCG) or `read:<path>` (SciTokens2) scope
- **Write operations** (`put`): Require `storage.create:<path>` (WLCG) or `write:<path>` (SciTokens2) scope
When obtaining tokens from your federation administrator or token issuer, ensure they include the necessary scopes for your intended operations.
### Token Validation
PelicanFS automatically validates tokens to ensure they:
- Have not expired
- Have the correct audience and issuer
- Have the necessary scopes for the requested operation
- Are authorized for the specific namespace path
## Integration with Data Science Libraries
PelicanFS integrates with any Python library that supports FFSpec.
### Using with xarray and Zarr
PelicanFS works with xarray for reading Zarr datasets:
```python
# Note: Replace example paths with actual Zarr dataset paths in your namespace
import xarray as xr
# Method 1: Using the scheme directly (recommended - simplest)
ds = xr.open_dataset('osdf:///namespace/remote/path/dataset.zarr', engine='zarr')
# Method 2: Using PelicanMap (useful for multiple datasets or custom configurations)
from pelicanfs.core import PelicanFileSystem, PelicanMap
pelfs = PelicanFileSystem("pelican://osg-htc.org")
zarr_store = PelicanMap('/namespace/remote/path/dataset.zarr', pelfs=pelfs)
ds = xr.open_dataset(zarr_store, engine='zarr')
# Method 3: Opening multiple datasets with PelicanMap
file1 = PelicanMap("/namespace/remote/path/file1.zarr", pelfs=pelfs)
file2 = PelicanMap("/namespace/remote/path/file2.zarr", pelfs=pelfs)
ds = xr.open_mfdataset([file1, file2], engine='zarr')
```
### Using with PyTorch
PelicanFS can be used to load training data for PyTorch:
```python
# Note: Replace example paths with actual training data paths in your namespace
import torch
from torch.utils.data import Dataset
import fsspec
class PelicanDataset(Dataset):
def __init__(self, file_paths, fs):
self.file_paths = file_paths
self.fs = fs
def __len__(self):
return len(self.file_paths)
def __getitem__(self, idx):
# Read file using filesystem instance
data = self.fs.cat(self.file_paths[idx])
# Process your data here
return data
# Method 1: Using fsspec.filesystem() (recommended)
fs = fsspec.filesystem('osdf')
files = fs.glob('/namespace/remote/path/**/*.bin')
dataset = PelicanDataset(files, fs)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)
# Method 2: Using PelicanFileSystem directly (for more control)
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org")
files = pelfs.glob('/namespace/remote/path/**/*.bin')
dataset = PelicanDataset(files, pelfs)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)
```
### Using with Pandas
Read CSV and other tabular data formats:
```python
# Note: Replace example path with your actual CSV file path
import pandas as pd
import fsspec
# Method 1: Using fsspec.open with schemes (recommended)
with fsspec.open('osdf:///namespace/remote/path/data.csv', 'r') as f:
df = pd.read_csv(f)
# Method 2: Read directly with pandas (pandas will use fsspec internally)
df = pd.read_csv('osdf:///namespace/remote/path/data.csv')
# Method 3: Using PelicanFileSystem directly
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org")
with pelfs.open('/namespace/remote/path/data.csv', 'r') as f:
df = pd.read_csv(f)
```
## Getting an FSMap
Some systems prefer a key-value mapper interface rather than a URL. Use `PelicanMap` for this:
```python
# Note: Replace example path with your actual dataset path
from pelicanfs.core import PelicanFileSystem, PelicanMap
pelfs = PelicanFileSystem("pelican://osg-htc.org")
mapper = PelicanMap("/namespace/remote/path/dataset.zarr", pelfs=pelfs)
# Use with xarray
import xarray as xr
ds = xr.open_dataset(mapper, engine='zarr')
```
**Note:** Use `PelicanMap` instead of fsspec's `get_mapper()` for better compatibility with Pelican's architecture.
## Monitoring and Debugging
### Access Statistics
PelicanFS tracks Cache access statistics to help diagnose performance issues. For each namespace path, it keeps the last three Cache access attempts.
**What the statistics show:**
- **NamespacePath**: The full Cache URL that was accessed
- **Success**: Whether the Cache access succeeded (`True`) or failed (`False`)
- **Error**: The exception type if the access failed (only shown on failures)
This helps identify:
- Which Caches are being used for your requests
- Cache reliability and failure patterns
- Whether Cache fallback is working correctly
**Example usage:**
```python
from pelicanfs.core import PelicanFileSystem
pelfs = PelicanFileSystem("pelican://osg-htc.org")
# Perform some operations
pelfs.cat('/pelicanplatform/test/hello-world.txt')
pelfs.cat('/pelicanplatform/test/hello-world.txt') # Second access
pelfs.cat('/pelicanplatform/test/hello-world.txt') # Third access
# Get access statistics object
stats = pelfs.get_access_data()
# Get responses for a specific path
responses, has_data = stats.get_responses('/pelicanplatform/test/hello-world.txt')
if has_data:
for resp in responses:
print(resp)
# Print all statistics in a readable format
stats.print()
```
**Example output:**
```
{NamespacePath: https://cache1.example.com/pelicanplatform/test/hello-world.txt, Success: True}
{NamespacePath: https://cache1.example.com/pelicanplatform/test/hello-world.txt, Success: True}
{NamespacePath: https://cache2.example.com/pelicanplatform/test/hello-world.txt, Success: False, Error: <class 'aiohttp.client_exceptions.ClientConnectorError'>}
/pelicanplatform/test/hello-world.txt: {NamespacePath: https://cache1.example.com/pelicanplatform/test/hello-world.txt, Success: True} {NamespacePath: https://cache1.example.com/pelicanplatform/test/hello-world.txt, Success: True} {NamespacePath: https://cache2.example.com/pelicanplatform/test/hello-world.txt, Success: False, Error: <class 'aiohttp.client_exceptions.ClientConnectorError'>}
```
### Enabling Debug Logging
Enable detailed logging to troubleshoot issues:
```python
import logging
# Set logging level for PelicanFS
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("fsspec.pelican")
logger.setLevel(logging.DEBUG)
```
**Logging levels and what they show:**
- `DEBUG`: Detailed information including cache URLs being tried, token discovery, Director responses, and all HTTP requests
- `INFO`: High-level operations like file opens, reads, and writes
- `WARNING`: Issues that don't prevent operation but may indicate problems (e.g., falling back to alternate caches)
- `ERROR`: Operation failures and exceptions
## API Reference
### PelicanFileSystem
Main class for interacting with Pelican federations.
#### Constructor Parameters
- `federation_discovery_url` (str): The Pelican federation discovery URL (e.g., `"pelican://osg-htc.org"`)
- `direct_reads` (bool, optional): If `True`, read directly from Origins instead of Caches. Default: `False`
- `preferred_caches` (list, optional): List of preferred Cache URLs. Use `"+"` to append Director's Caches
- `headers` (dict, optional): HTTP headers to include in requests. Use for authorization: `{"Authorization": "Bearer TOKEN"}`
- `oidc_timeout_seconds` (int, optional): Timeout in seconds for the OIDC device flow. Default: `300`
- `use_listings_cache` (bool, optional): Enable caching of directory listings. Default: `False`
- `asynchronous` (bool, optional): Use async mode. Default: `False`
- `**kwargs`: Additional arguments passed to the underlying HTTP filesystem
#### Methods
##### Object Operations
- `ls(path, detail=True, **kwargs)` - List objects in a collection
- `cat(path, recursive=False, on_error="raise", **kwargs)` - Read object contents
- `open(path, mode, **kwargs)` - Open an object for reading (write modes not supported; use `put()` instead)
- `glob(path, maxdepth=None, **kwargs)` - Find objects matching a pattern
- `find(path, maxdepth=None, withdirs=False, **kwargs)` - Recursively list all objects
- `put(lpath, rpath, recursive=False, **kwargs)` - Upload local file(s) as remote object(s)
- `get(rpath, lpath, recursive=False, **kwargs)` - Download remote object(s) to local file(s)
##### Utility Methods
- `get_access_data()` - Get Cache access statistics
- `info(path, **kwargs)` - Get detailed information about an object
- `exists(path, **kwargs)` - Check if a path exists
- `isfile(path, **kwargs)` - Check if a path is an object
- `isdir(path, **kwargs)` - Check if a path is a collection
### OSDFFileSystem
Convenience class that automatically connects to the OSDF federation (which uses `osg-htc.org` for its discovery URL).
```python
from pelicanfs.core import OSDFFileSystem
# Equivalent to PelicanFileSystem("pelican://osg-htc.org")
osdf = OSDFFileSystem()
```
### PelicanMap
Create a filesystem mapper for use with libraries like xarray.
```python
PelicanMap(root, pelfs, check=False, create=False)
```
**Parameters:**
- `root` (str): The namespace path within Pelican to use as the base of this mapper (e.g., `/namespace/path/dataset.zarr`). This acts like a mount point - paths within the mapper are relative to this base path.
- `pelfs` (PelicanFileSystem): An initialized PelicanFileSystem instance
- `check` (bool, optional): Check if the path exists. Default: `False`
- `create` (bool, optional): Inherited from fsspec's FSMap but not functional in PelicanFS (operations like `mkdir` are not supported). Default: `False`
## Troubleshooting
### Common Issues
**Problem:** `NoAvailableSource` error when trying to access a file
**Solution:** This usually means no Cache or Origin is available for the namespace. Check:
- The namespace path is correct
- The federation URL is correct
- Network connectivity to the federation
- Try enabling `direct_reads=True` to bypass Caches
**Problem:** `403 Forbidden` or authorization errors
**Solution:**
- Ensure you've provided a valid token via the `headers` parameter or one of the other token discovery methods (see [Authorization](#authorization))
- Verify the token hasn't expired
**Problem:** Slow performance
**Solution:**
- Enable `use_listings_cache=True` if you're doing many directory listings
**Problem:** `NotImplementedError` for certain operations
**Solution:** PelicanFS doesn't support `rm`, `cp`, `mkdir`, or `makedirs` operations as they're not available in the underlying HTTP filesystem. Use alternative approaches or the Pelican command-line tools.
## Contributing
Contributions are welcome! Please see our [GitHub repository](https://github.com/PelicanPlatform/pelicanfs) for reporting issues and submitting pull requests.
## License
PelicanFS is licensed under the Apache License 2.0. See the LICENSE file for details.
## Citation
If you use PelicanFS in your research, please cite:
```bibtex
@software{pelicanfs,
author = {Pelican Platform Team},
title = {PelicanFS: A filesystem interface for the Pelican Platform},
year = {2024},
doi = {10.5281/zenodo.13376216},
url = {https://github.com/PelicanPlatform/pelicanfs}
}
```
## Support
For questions, issues, or support:
- Open an issue on [GitHub](https://github.com/PelicanPlatform/pelicanfs/issues)
- Join our [community discussions](https://github.com/PelicanPlatform/pelican/discussions)
- Visit the [Pelican Platform website](https://pelicanplatform.org)
| text/markdown | null | Pelican Platform Developers <info@pelicanplatform.org> | null | null | null | pelican, fsspec | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Science/Research",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3 :: Only"
] | [] | null | null | <4,>=3.11 | [] | [] | [] | [
"aiohttp<4,>=3.9.4",
"aiowebdav2",
"cachetools<6,>=5.3",
"fsspec>=2024.3.1",
"igwn-auth-utils",
"pywinpty; platform_system == \"Windows\""
] | [] | [] | [] | [
"Source, https://github.com/PelicanPlatform/pelicanfs",
"Pelican-Source, https://github.com/PelicanPlatform/pelican",
"Bug-Reports, https://github.com/PelicanPlatform/pelicanfs/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:37:19.380243 | pelicanfs-1.3.1.tar.gz | 77,542 | 3d/47/3214cbf12cdb85ec253d6e0d4594dd21b39859c951ff0e0db300a79941d2/pelicanfs-1.3.1.tar.gz | source | sdist | null | false | 1f2cf97326b2bd432137853145694c79 | fc650efbaf2863eb072aab8624452a63f304dad472934402f862ad05e5b7a958 | 3d473214cbf12cdb85ec253d6e0d4594dd21b39859c951ff0e0db300a79941d2 | Apache-2.0 | [
"LICENSE"
] | 189 |
2.4 | uv-workon | 0.7.4 | Tools to activate and run virtual environments from central location | <!-- 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]
[![Code style: ruff][ruff-badge]][ruff-link]
[![uv][uv-badge]][uv-link]
<!-- [![Conda (channel only)][conda-badge]][conda-link] -->
<!--
For more badges, see
https://shields.io/category/other
https://naereen.github.io/badges/
[pypi-badge]: https://badge.fury.io/py/uv-workon
-->
[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/uv-workon
[pypi-link]: https://pypi.org/project/uv-workon
[docs-badge]: https://img.shields.io/badge/docs-sphinx-informational
[docs-link]: https://pages.nist.gov/uv-workon/
[repo-badge]: https://img.shields.io/badge/--181717?logo=github&logoColor=ffffff
[repo-link]: https://github.com/usnistgov/uv-workon
<!-- [conda-badge]: https://img.shields.io/conda/v/wpk-nist/uv-workon -->
<!-- [conda-link]: https://anaconda.org/wpk-nist/uv-workon -->
[license-badge]: https://img.shields.io/pypi/l/uv-workon?color=informational
[license-link]: https://github.com/usnistgov/uv-workon/blob/main/LICENSE
[changelog-link]: https://github.com/usnistgov/uv-workon/blob/main/CHANGELOG.md
<!-- other links -->
[uv]: https://docs.astral.sh/uv/
[virtualenvwrapper]: https://virtualenvwrapper.readthedocs.io/en/latest/
[conda]: https://github.com/conda/conda
[uv-central-discussion]: https://github.com/astral-sh/uv/issues/1495
<!-- prettier-ignore-end -->
# `uv-workon`
Command line program `uv-workon` to work with multiple [uv] based virtual
environments.
## Overview
[`uv`][uv] has taken the python world by storm, and for good reason. It manages
projects, dependencies, virtual environment creation, and much more, all while
being blazingly fast. One of the central ideas of [uv] is that the old method of
activating virtual environments should be replace with `uv run ...` and letting
[uv] figure out the rest. We fully agree with this workflow, but it does run
counter to how many have used python virtual environments day to day for data
work. For example, many have historically used tools like [`conda`][conda] or
[`virtualenvwrapper`][virtualenvwrapper] to manage centrally located python
environments, that can be reused for multiple tasks. While we discorage using
"mega" environments (i.e., sticking every dependency you'll ever need in a
single python environments), there is utility in using a virtual environment for
multiple tasks. There is [active discussion][uv-central-discussion] regarding if
and how [uv] should manage centralized virtual environments.
We takes the perspective that python virtual environments should be managed with
uv inside a project. `uv-workon` allows for the usage of such virtual
environments _outside_ the project. The basic workflow is as follows:
1. Create a project `my-project` using `uv init ...`
2. Create a virtual environment `my-project/.venv` using `uv sync ...`
3. Link to central location using `uv-workon link my-project`
Now, from anywhere, you can use the virtual environment `my-project`:
- Activate with `uv-workon activate -n my-project`
- Run python using the `my-project` virtual environment with
`uv-workon run -n my-project ...`
- Change to the `my-project` project directory with `uv-workon cd -n my-project`
## Features
- Link virtual environment to central location with `uv-workon link`. These
links are located at `WORKON_HOME` environment variable, defaulting to
`~/.virtualenvs`.
- Activate virtual environment with `uv-workon activate ...` (requires shell
integration)
- Run under virtual environment with `uv-workon run ...`
- Change to project directory with `uv-workon cd ...` (requires shell
integration)
- List available virtual environments with `uv-workon list`
- Cleanup missing symlinks with `uv-workon clean`
- Manage [`ipykernel`](https://github.com/ipython/ipykernel) with
`uv-workon kernels ...`
- Install kernels for linked virtual environments which have `ipykernel`
installed with `uv-workon kernels install ...`
- Remove kernels (including remove all missing/broken kernels) with
`uv-workon kernels remove ...`
- list installed kernels with `uv-workon kernels list ...`
## Status
This package is actively used by the author. Please feel free to create a pull
request for wanted features and suggestions!
<!-- end-docs -->
## Quick start
<!-- start-installation -->
It is recommended to install with [`uv`](https://docs.astral.sh/uv/):
```bash
uv tool install uv-workon
```
To include the ability to manage
[`ipykernel`](https://github.com/ipython/ipykernel), include the `jupyter`
extra:
```bash
uv tool install "uv-workon[jupyter]"
```
### Add autocompletion
Run the following to add autocompletion for `uv-workon`:
```bash
uv-workon --install-completion
```
### Shell integration
To use `uv-workon activate` and `uv-workon cd`, you must enable the shell
configuration with `eval "$(uv-workon shell-config)", or add it to you config
script with:
```bash
# for zsh
echo 'eval "$(uv-workon shell-config)"' >> ~/.zshrc
# for bash
echo 'eval "$(uv-workon shell-config)"' >> ~/.bashrc
# for fish
echo 'uv-workon shell-config | source' >> ~/.config/fish/completions/uv-workon.fish
```
Open a issue if you need support for another shell.
<!-- end-installation -->
## Documentation
See the [documentation][docs-link] for further details.
## What's new?
See [changelog][changelog-link].
## License
This is free software. See [LICENSE][license-link].
## Related work
Any other stuff to mention....
## 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 | uv-workon | [
"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 | [] | [] | [] | [
"attrs>=25.3.0",
"typer>=0.15.2",
"typing-extensions>=4.12.2; python_full_version < \"3.11\"",
"uv-workon[jupyter,menu]; extra == \"all\"",
"jupyter-client>=8.6.3; extra == \"jupyter\"",
"simple-term-menu>=1.6.6; extra == \"menu\""
] | [] | [] | [] | [
"Documentation, https://pages.nist.gov/uv-workon/",
"Homepage, https://github.com/usnistgov/uv-workon"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:37:07.951639 | uv_workon-0.7.4.tar.gz | 23,351 | 05/02/fdd95920630766b0c3c36684d88525370f26449102d2cb5e3d16793a042c/uv_workon-0.7.4.tar.gz | source | sdist | null | false | be9336628416567c9f75588fb5b51645 | 1439234cffe4879393e657f48f11377cc2092e666b8c79860b130c8f616e188a | 0502fdd95920630766b0c3c36684d88525370f26449102d2cb5e3d16793a042c | NIST-PD | [
"LICENSE"
] | 193 |
2.4 | cogmemai | 1.0.1 | CogmemAi — Persistent memory for AI coding assistants | # CogmemAi Python SDK
Persistent memory for AI coding assistants. Give your AI tools memory that persists across sessions.
## Install
```bash
pip install cogmemai
```
## Quick Start
```python
from cogmemai import CogmemAi
client = CogmemAi("cm_your_api_key_here")
# Save a memory
client.save_memory(
content="This project uses React with TypeScript",
memory_type="architecture",
category="frontend",
importance=8,
)
# Search memories
results = client.recall_memories("what framework does this project use?")
for memory in results["memories"]:
print(f"[{memory['importance']}] {memory['content']}")
# Load project context
context = client.get_project_context(project_id="my-project")
# Extract memories from conversation
client.extract_memories(
user_message="Let's use PostgreSQL for the database",
assistant_response="Good choice. I'll set up the schema with...",
)
```
## All Methods
### Core Memory
- `save_memory(content, memory_type, category, subject, importance, scope, project_id)` — Save a memory
- `recall_memories(query, limit, memory_type, scope)` — Semantic search
- `extract_memories(user_message, assistant_response, previous_context)` — Ai extracts facts from conversation
- `get_project_context(project_id, include_global, context)` — Load top memories with smart ranking
- `list_memories(memory_type, category, scope, limit, offset)` — Browse with filters
- `update_memory(memory_id, content, importance, scope)` — Edit a memory
- `delete_memory(memory_id)` — Delete permanently
- `get_usage()` — Check usage stats and tier
### Documents & Sessions
- `ingest_document(text, document_type, project_id)` — Extract memories from docs
- `save_session_summary(summary, project_id)` — Capture session accomplishments
### Import / Export
- `export_memories()` — Back up memories as JSON
- `import_memories(memories)` — Bulk import from JSON
- `get_memory_versions(memory_id)` — Version history
### Team & Collaboration
- `get_team_members(project_id)` — List team members
- `invite_team_member(email, project_id, role)` — Invite a member
- `remove_team_member(member_id)` — Remove a member
### Memory Relationships & Promotion
- `link_memories(memory_id, related_memory_id, relationship_type)` — Link related memories
- `get_memory_links(memory_id)` — Get linked memories
- `get_promotion_candidates()` — Find cross-project patterns
- `promote_to_global(memory_id)` — Promote to global scope
## Error Handling
```python
from cogmemai.client import CogmemAiError
try:
client.save_memory(content="test")
except CogmemAiError as e:
print(f"Error {e.status_code}: {e}")
```
## Get an API Key
1. Sign up at [hifriendbot.com/developer/](https://hifriendbot.com/developer/)
2. Generate an API key
3. Start saving memories
## Links
- [Developer Dashboard](https://hifriendbot.com/developer/)
- [JavaScript SDK (npm)](https://www.npmjs.com/package/cogmemai-sdk)
- [MCP Server (npm)](https://www.npmjs.com/package/cogmemai-mcp)
- [GitHub](https://github.com/hifriendbot/cogmemai-python)
| text/markdown | null | HiFriendbot <developers@hifriendbot.com> | null | null | null | ai, claude, coding-assistant, developer-tools, mcp, memory | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"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",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"requests>=2.28"
] | [] | [] | [] | [
"Homepage, https://hifriendbot.com/developer/",
"Documentation, https://hifriendbot.com/developer/",
"Repository, https://github.com/hifriendbot/cogmemai-python",
"Issues, https://github.com/hifriendbot/cogmemai-python/issues"
] | twine/6.2.0 CPython/3.14.0 | 2026-02-20T17:36:35.513135 | cogmemai-1.0.1.tar.gz | 5,904 | 96/90/26040d559c480720c036bc8da970e59f1027113a12a3dbaa88d668629f6d/cogmemai-1.0.1.tar.gz | source | sdist | null | false | 35d6fe29f247b5a80f67771671ea9f7a | 5ab9cbd1bb4a3fabe0e03d98e16fe6283580fe55d0fe3667bf3ccaf40e639712 | 969026040d559c480720c036bc8da970e59f1027113a12a3dbaa88d668629f6d | MIT | [
"LICENSE"
] | 179 |
2.4 | foundry-sandbox | 0.18.2 | Docker-based sandbox environment for running Claude Code with isolated credentials | # Foundry Sandbox
Safe, ephemeral workspaces for AI-assisted coding—isolate mistakes, not productivity.
## Overview
Your API keys and tokens are exposed to everything running on your machine—including malicious dependencies, compromised tools, and AI assistants that might leak them. Supply chain attacks are increasingly common, and a single `npm install` can run arbitrary code with access to your credentials.
Foundry Sandbox provides ephemeral Docker workspaces where credentials never enter the container. A unified proxy holds your real API keys and tokens on the host, injecting them into outbound requests only after validation. Code running inside the sandbox—whether it's an AI assistant, a build script, or a malicious package—never sees the actual credentials.
Beyond credential isolation, sandboxes provide defense in depth:
- **Read-only filesystem** — Prevents destructive commands like `rm -rf /`
- **Network allowlists** — Egress restricted to approved domains (GitHub, AI APIs, etc.)
- **Disposable worktrees** — Each sandbox is a git worktree; create in seconds, destroy with zero trace
- **Multi-tool ready** — Claude Code, Gemini CLI, Codex CLI, and OpenCode pre-installed
The result: run AI assistants and untrusted code with the confidence that your credentials and host system are protected by multiple independent security layers.
Finally, in addition to providing tight security guardrails, this sandbox is designed to enable spec-driven development using the `foundry-mcp` server and `claude-foundry` plugin, which are automatically installed and pre-configured.
## Key Features
- **Ephemeral Workspaces** - Git worktrees per sandbox; destroy when done with no trace
- **Defense in Depth** - Multiple security pillars enforced by Docker and the kernel
- **Multiple AI Tools** - Claude Code, Gemini CLI, Codex CLI, and OpenCode pre-installed
- **Fast Creation** - Worktrees share git objects; new sandboxes spin up in seconds
- **Network Control** - Limited (allowlist), host-only, or no network access
- **Credential Isolation** - API keys stay outside sandboxes via proxy (enabled by default)
- **Branch Isolation** - Each sandbox restricted to its own git branch; other sandboxes' branches hidden
- **Git Safety** - Protected branch enforcement, force-push blocking, GitHub API operation controls
- **Presets & History** - Save configurations as presets; repeat last command with `cast repeat`
- **Volume Mounts** - Mount host directories read-write or read-only
- **JSON Output** - All commands support `--json` for scripting and automation
## Prerequisites
| Requirement | Version | Check Command |
|-------------|---------|---------------|
| Docker | 20.10+ | `docker --version` |
| Git | 2.x+ | `git --version` |
| Bash | 4.x+ | `bash --version` |
| tmux | 3.x+ | `tmux -V` |
| Python | 3.10+ | `python3 --version` |
Linux and macOS supported natively. Windows users need WSL2. macOS ships Bash 3.2—install Bash 4+ via `brew install bash`. Python 3.10+ is required.
## Installation
### Full install (recommended)
```bash
curl -fsSL https://raw.githubusercontent.com/foundry-works/foundry-sandbox/main/install.sh | bash
```
This will clone to `~/.foundry-sandbox`, add the `cast` alias to your shell, enable tab completion, and build the Docker image.
For manual installation or uninstall instructions, see [Getting Started](docs/getting-started.md).
### PyPI package
`foundry-sandbox` is published on PyPI and provides the `cast` Python entry point:
```bash
pipx install foundry-sandbox
# or
pip install foundry-sandbox
```
Important: full sandbox operation still requires repository runtime assets (`docker-compose.yml`, `docker-compose.credential-isolation.yml`, `unified-proxy/`, `stubs/`). Use the installer above (or clone the repo and run `pip install -e .`) for a complete setup.
## Quick Start
**1. Create a sandbox**
```bash
cast new
```
The guided wizard walks you through repo selection, branch strategy, and options. It detects your current repo and offers smart defaults.
For scripting or quick one-liners:
```bash
cast new owner/repo # From GitHub
cast new . # From current repo/branch
cast new . feature-branch main # Create new branch from main
```
**2. Run an AI assistant**
```bash
claude # Claude Code
gemini # Gemini CLI
codex # Codex CLI
opencode # OpenCode
```
**3. Commit and push your changes**
```bash
git add -A && git commit -m "Add feature"
git push origin HEAD
```
**4. Destroy when done**
```bash
cast destroy sandbox-name --yes
```
**Tip: Save configurations for reuse**
```bash
cast new owner/repo feature --wd packages/app --save-as myproject # save preset
cast new --preset myproject # reuse later
cast repeat # repeat last command
```
## Limitations
- **Not a targeted-attack boundary** - Protects against automated threats (supply chain attacks, credential-stealing packages) and AI mistakes, but not a targeted human attacker with Docker access on the host
- **Requires Docker** - No native process isolation; container overhead applies
- **Linux/macOS focus** - Windows requires WSL2
- **No GPU passthrough** - GPU workloads need additional Docker configuration
## Documentation
| Document | Description |
|----------|-------------|
| [Getting Started](docs/getting-started.md) | Installation and first sandbox |
| [Commands](docs/usage/commands.md) | Full command reference |
| [Workflows](docs/usage/workflows.md) | Common patterns and recipes |
| [Configuration](docs/configuration.md) | API keys, plugins, and config files |
| [Architecture](docs/architecture.md) | Technical design and diagrams |
| [Security Overview](docs/security/index.md) | Security architecture quick reference |
| [Sandbox Threats](docs/security/sandbox-threats.md) | AI-as-threat-actor model |
| [Security Architecture](docs/security/security-architecture.md) | Security pillars and defense layers |
| [Credential Isolation](docs/security/credential-isolation.md) | Credential isolation threat model |
| [Network Isolation](docs/security/network-isolation.md) | Network architecture details |
| [Operations](docs/operations.md) | Proxy operations runbook |
| [Observability](docs/observability.md) | Metrics and debugging |
| [Certificates](docs/certificates.md) | CA certificate management |
| [Contributing](docs/development/contributing.md) | For contributors |
## Support
- **Issues**: [GitHub Issues](https://github.com/foundry-works/foundry-sandbox/issues)
- **Discussions**: [GitHub Discussions](https://github.com/foundry-works/foundry-sandbox/discussions)
## License
MIT License. See [LICENSE](LICENSE) for details.
| text/markdown | Foundry Works | null | null | null | null | ai, claude, docker, isolation, sandbox | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: MacOS",
"Operating System :: POSIX :: Linux",
"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 :: Testing"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"click>=8.1",
"packaging>=21.0",
"pydantic>=2.0",
"hypothesis>=6.100; extra == \"dev\"",
"mypy>=1.10; extra == \"dev\"",
"pytest-cov>=5.0; extra == \"dev\"",
"pytest-timeout>=2.3; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.5; extra == \"dev\"",
"pyyaml>=6.0; extra == \"test-orchestration\"",
"flask>=3.0; extra == \"test-proxy\"",
"httpx>=0.25.0; extra == \"test-proxy\"",
"mitmproxy>=10.0; extra == \"test-proxy\"",
"pyyaml>=6.0; extra == \"test-proxy\""
] | [] | [] | [] | [
"Homepage, https://github.com/foundry-works/foundry-sandbox",
"Repository, https://github.com/foundry-works/foundry-sandbox",
"Issues, https://github.com/foundry-works/foundry-sandbox/issues",
"Documentation, https://github.com/foundry-works/foundry-sandbox/tree/main/docs"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:36:06.502163 | foundry_sandbox-0.18.2.tar.gz | 670,529 | f4/d1/2764e9acd46704e480a885fd720af81b047d7c5dd4961bbcd4ef44ebbbc9/foundry_sandbox-0.18.2.tar.gz | source | sdist | null | false | e7d6d7b5258b9583227f9fa9a8a04e68 | 8968e8fbd9b2c9caabf6942372a9c0d0abe5a559c23a876bc2576f43c66082d1 | f4d12764e9acd46704e480a885fd720af81b047d7c5dd4961bbcd4ef44ebbbc9 | MIT | [
"LICENSE"
] | 189 |
2.4 | aiden3drenderer | 1.1.4 | A lightweight 3D wireframe renderer built from scratch using Pygame | # Aiden3DRenderer
A lightweight 3D wireframe renderer built with Pygame featuring custom projection, first-person camera controls, and 15+ procedural terrain generators.
## Features
- **Custom 3D projection** - Perspective projection without using external 3D libraries
- **First-person camera** - Full 6-DOF camera movement with mouse look
- **15+ procedural generators** - Mountains, cities, fractals, and mathematical surfaces
- **Real-time rendering** - 60 FPS wireframe rendering
- **Animated terrains** - Several terrains feature time-based animations
- **Extensible API** - Easy to create and register custom shapes with decorators
- **Multiple Object Support** - Render multiple shapes at the same time
- **Custom Colors** - Ability to change colors on a per shape basis
- **Simple Physics Engine** - easy to add physics to your render
## Gallery
<div align="center">
<table>
<tr>
<td align="center">
<img src="media/RenderShowcase.gif" alt="Ripple Animation" width="400"/>
<br/>
<b>Ripple Effect</b>
<br/>
<i>Expanding waves from center</i>
</td>
<td align="center">
<img src="media/plateau_thing.png" alt="Mandelbulb Fractal" width="400"/>
<br/>
<b>Mandelbulb Slice</b>
<br/>
<i>3D fractal cross-section</i>
</td>
</tr>
<tr>
<td align="center">
<img src="media/Spiral.gif" alt="Turning Spiral" width="400"/>
<br/>
<b>Turning Spiral</b>
<br/>
<i>Screw like shape spinning</i>
</td>
<td align="center">
<img src="media/City.png" alt="Simple City (laggy when solid render)" width="400"/>
<br/>
<b>Simple City (laggy when solid render)</b>
<br/>
<i>City preset in solid render</i>
</td>
<tr>
<td align="center">
<img src="media/DualObjMesh.png" alt="Tree Mesh" width="400"/>
<br/>
<b>Tree Mesh</b>
<br/>
<i>Tree render from tree_example.py in examples</i>
</td>
<td align="center">
<img src="media/DualObjFull.png" alt="Tree Solid Render" width="400"/>
<br/>
<b>Tree Solid Render</b>
<br/>
<i>Tree render from tree_example.py in examples</i>
</td>
</tr>
<tr>
<td align="center">
<img src="media/ColorTree.png" alt="Colored Tree" width="400"/>
<br/>
<b>Colored Tree</b>
<br/>
<i>Tree render from tree_example.py in examples (with color update)</i>
</td>
<td align="center">
<img src="media/PhysicsDemo.gif" alt="Physics Demo" width="400"/>
<br/>
<b>Physics Demo</b>
<br/>
<i>Physics Demo from physics_test.py in examples</i>
</td>
</tr>
</table>
</div>
## Installation
```bash
pip install aiden3drenderer
```
Requires Python 3.11+ and automatically installs Pygame 2.6.0+
(only tested with Python 3.11)
## Quick Start
### Running the Demo
#### Original Demo
```python
from aiden3drenderer import Renderer3D
# Create and run the renderer with all built-in shapes
renderer = Renderer3D()
renderer.camera.position = [0, 0 ,0]
# is_mesh = True for mesh, False for solid colors
renderer.is_mesh = False
renderer.run()
```
#### Looped Demo
```python
from aiden3drenderer import Renderer3D
# Create and run the renderer with all built-in shapes
renderer = Renderer3D()
renderer.camera.position = [0, 0 ,0]
# is_mesh = True for mesh, False for solid colors
renderer.is_mesh = False
while True:
renderer.loopable_run()
```
### Looped Run Usage Example
```python
from aiden3drenderer import Renderer3D
# Create and run the renderer with all built-in shapes
# Simple gravity with set floor height
renderer = Renderer3D()
renderer.camera.position = [0, 0 ,0]
renderer.is_mesh = False
gravity = 0.05
floor_height = 0.1
camera_height = 2
while True:
if renderer.camera.position[1] <= floor_height + camera_height:
renderer.camera.position[1] = floor_height + camera_height
else:
renderer.camera.position[1] -= gravity
renderer.loopable_run()
```
### Creating Custom Shapes
To create custom shapes compatible with this 3D mesh renderer, you must write Python functions decorated with `@register_shape`, each returning a "vertex matrix"—a list of rows, where each row is a list of 3D coordinate tuples (x, y, z). Each row represents a contiguous horizontal strip of points on your 3D shape, stacked along the "y" (vertical) dimension. All rows in the matrix must have the **same number of points** (columns); do not generate jagged matrices or append rows of different lengths, as the renderer expects a perfect rectangle to traverse for drawing wireframes and faces.
Points are usually arranged such that `matrix[row][col]` gives the (x, y, z) of the point at column `col` in row `row`. Loops that fill your matrix should ensure that each sub-list (row) is always the full width—pad with `None` or duplicate valid coordinates if needed, but empty or missing values will cause indexing errors. Avoid using polar or arbitrary arrangements for each row: either fill every cell with an (x, y, z) tuple, or, if the shape doesn't naturally fit a rectangle (e.g., cones/canopies), pad shorter rows to the full length to maintain a perfect rectangle.
Your function should accept at least the two arguments `grid_size` (which determines the overall scale and discretization) and `frame` (for animation support; ignored if not animating), and always return the correctly-sized 2D matrix ready for rendering. If any row in your matrix is shorter than the others, or you index cells that do not exist, you will get `IndexError: list index out of range`. Review your logic to ensure each row always contains the expected number of vertices, and debug with simple cubes or grids first to be confident in your shape's layout.
To render multiple shapes at the same time, simply have the shapes use the same key press activation as another shape.
#### Simple Shapes
```python
from aiden3drenderer import Renderer3D, register_shape
import pygame
# Register a custom shape with a decorator
# @register_shape("My Plane", key=pygame.K_p, is_animated=False) would have default purple colors
@register_shape("My Plane", key=pygame.K_p, is_animated=False, color=(200, 255, 150))
def generate_pyramid(grid_size=40, frame=0):
"""Generate a simple plane."""
matrix = [
[(1,1,1), (2,1,1), (3,1,1)],
[(1,1,2), (2,1,2), (3,1,2)],
[(1,1,3), (2,1,3), (3,1,3)]
]
return matrix
# Run the renderer (your shape will be available on 'P' key)
renderer = Renderer3D()
renderer.run()
```
#### Complex Shapes
```python
from aiden3drenderer import Renderer3D, register_shape
import pygame
# Register a custom shape with a decorator
@register_shape("My Pyramid", key=pygame.K_p, is_animated=False)
def generate_pyramid(grid_size=40, frame=0):
"""Generate a simple pyramid."""
matrix = []
center = grid_size / 2
for x in range(grid_size):
row = []
for y in range(grid_size):
# Distance from center
dx = abs(x - center)
dy = abs(y - center)
max_dist = max(dx, dy)
# Height decreases with distance
height = max(0, 10 - max_dist)
row.append(height)
matrix.append(row)
return matrix
# Run the renderer (your shape will be available on 'P' key)
renderer = Renderer3D()
renderer.run()
```
## Physics
### About
The physics engine in Aiden3DRenderer provides a simple but extensible framework for simulating basic 3D physics interactions. It supports rigid body dynamics for spheres and planes, including gravity, velocity, and collision detection/response. The system allows you to:
- Add physical objects (spheres, planes) to your scene with mass, size, and color
- Apply forces (like gravity or impulses) to objects
- Simulate collisions between spheres and with planes (walls, floor, etc.)
- Attach a physics-enabled camera that can move and collide with the environment
- Easily manage all physics objects using a handler class
This makes it easy to create interactive demos, simple games, or visualizations where objects move and bounce realistically within a 3D environment. The physics system is designed to be lightweight and easy to integrate with the renderer, while remaining flexible for custom extensions.
### Examples:
#### 2 balls colliding:
```python
from aiden3drenderer import Renderer3D, register_shape, physics
import pygame
import math
def main():
# Create the renderer
renderer = Renderer3D(width=1000, height=1000, title="My 3D Renderer")
# Add physics shapes
shape = physics.ShapePhysicsObject(renderer, "sphere", (0,0,0), (100, 0, 0), 5, 20, 20)
shape.add_forces((-0.7, 0, 0))
shape.anchor_position = [20, 0, 0]
shape1 = physics.ShapePhysicsObject(renderer, "sphere", (0,0,0), (50, 0, 0), 5, 10, 20)
shape1.add_forces((0.7, 0, 0))
shape1.anchor_position = [0, 0, 0]
# Create object handler
obj_handler = physics.PhysicsObjectHandler()
# Add all shapes
obj_handler.add_shape(shape)
obj_handler.add_shape(shape1)
# Set starting shape (optional)
renderer.set_starting_shape(None)
renderer.camera.position = [0, 0 ,0]
renderer.is_mesh = False
# Run the renderer
while True:
obj_handler.handle_shapes()
renderer.loopable_run()
if __name__ == "__main__":
main()
```
#### 2 balls in a box, camera physics too:
```python
from aiden3drenderer import Renderer3D, register_shape, physics
import pygame
import math
def main():
# Create the renderer
renderer = Renderer3D(width=1000, height=1000, title="My 3D Renderer")
obj_handler = physics.PhysicsObjectHandler()
plane_color = (200, 200, 200)
plane_size = 28 # Slightly larger box
grid_size = 8 # Slightly higher resolution
obj_handler.add_plane(renderer, [0, -14, 0], (0, 0, 0), plane_color, plane_size, grid_size) # floor
obj_handler.add_plane(renderer, [-14, 0, 0], (0, 0, 90), plane_color, plane_size, grid_size) # left
obj_handler.add_plane(renderer, [14, 0, 0], (0, 0, 90), plane_color, plane_size, grid_size) # right
obj_handler.add_plane(renderer, [0, 0, -14], (90, 0, 0), plane_color, plane_size, grid_size) # back
obj_handler.add_plane(renderer, [0, 0, 14], (90, 0, 0), plane_color, plane_size, grid_size) # front
# Create two balls (spheres) inside the box
ball_color = (100, 100, 255)
ball_radius = 4 # Slightly larger balls
ball_mass = 2.5
ball_grid = 8 # Slightly higher resolution
ball1 = physics.ShapePhysicsObject(renderer, "sphere", (0, 0, 0), ball_color, ball_radius, ball_mass, ball_grid)
ball1.anchor_position = [0, 0, 0]
ball2 = physics.ShapePhysicsObject(renderer, "sphere", (0, 0, 0), ball_color, ball_radius, ball_mass, ball_grid)
ball2.anchor_position = [9, 0, 0]
# Gravity force (downwards)
gravity = (0, -0.18, 0)
ball1.add_forces((1,0,1))
camera = physics.CameraPhysicsObject(renderer, renderer.camera, 1, 10)
obj_handler.add_camera(camera)
# Add balls
obj_handler.add_shape(ball1)
obj_handler.add_shape(ball2)
renderer.set_starting_shape(None)
renderer.is_mesh = False
renderer.camera.base_speed = 1.2
while True:
keys = pygame.key.get_pressed()
old_pos = list(renderer.camera.position)
renderer.camera.update(keys)
new_pos = renderer.camera.position
camera.anchor_position[0] += new_pos[0] - old_pos[0]
camera.anchor_position[1] += new_pos[1] - old_pos[1]
camera.anchor_position[2] += new_pos[2] - old_pos[2]
renderer.camera.position = old_pos
ball1.add_forces(gravity)
ball2.add_forces(gravity)
camera.add_forces(gravity*100)
obj_handler.handle_shapes()
renderer.loopable_run()
if __name__ == "__main__":
main()
```
## Controls
### Camera Movement
- **W/A/S/D** - Move forward/left/backward/right
- **Space** - Move up
- **Left Shift** - Move down
- **Left Ctrl** - Speed boost (2x)
- **Arrow Keys** - Fine pitch/yaw adjustment
- **Right Mouse + Drag** - Look around (pitch and yaw)
### Terrain Selection
- **1** - Mountain terrain
- **2** - Animated sine waves
- **3** - Ripple effect
- **4** - Canyon valley
- **5** - Stepped pyramid
- **6** - Spiral surface
- **7** - Torus (donut)
- **8** - Sphere
- **9** - Möbius strip
- **0** - Megacity (80×80 procedural city)
- **Q** - Alien landscape
- **E** - Double helix (DNA-like)
- **R** - Mandelbulb fractal slice
- **T** - Klein bottle
- **Y** - Trefoil knot
### Other
- **Escape** - Quit application
## Terrain Descriptions
### Static Terrains
**Mountain** (1) - Smooth parabolic mountain with radial falloff
**Canyon** (4) - U-shaped valley with sinusoidal variations
**Pyramid** (5) - Stepped pyramid using Chebyshev distance
**Torus** (7) - Classic donut shape using parametric equations
**Sphere** (8) - UV sphere using spherical coordinates
**Möbius Strip** (9) - Non-orientable surface with a single side
**Megacity** (0) - 80×80 grid with hundreds of procedurally generated buildings
- Buildings get taller toward the center
- 8×8 block system with roads
- Random antenna towers on some buildings
- Most complex terrain (6400 vertices)
**Mandelbulb** (R) - 2D slice of 3D Mandelbulb fractal
- Uses power-8 formula
- Height based on iteration count
**Klein Bottle** (T) - 4D object projected into 3D
- Non-orientable surface
- No inside or outside
**Trefoil Knot** (Y) - Mathematical knot in 3D space
- Classic topology example
- Tube follows trefoil path
### Animated Terrains
**Waves** (2) - Multiple overlapping sine waves
- Three different wave frequencies
- Constantly flowing motion
**Ripple** (3) - Expanding ripple from center
- Exponential amplitude decay
- Simulates water drop impact
**Spiral** (6) - Rotating spiral pattern
- Polar coordinate mathematics
- Hypnotic rotation
**Alien Landscape** (Q) - Complex multi-feature terrain
- Crater with parabolic profile
- Crystalline spike formations
- Rolling hills
- Procedural "vegetation" spikes
- Pulsating energy field
**Double Helix** (E) - DNA-like structure
- Two intertwined strands
- 180° phase offset between strands
- Rotates over time
## Technical Details
### 3D Projection Pipeline
1. **World coordinates** - Raw vertex positions
2. **Camera translation** - Subtract camera position
3. **Camera rotation** - Apply yaw, pitch, roll transformations
4. **Perspective projection** - Divide by Z-depth with FOV
5. **Screen mapping** - Convert to pixel coordinates
### Rotation Matrices
Yaw (Y-axis):
```
x' = x·cos(θ) + z·sin(θ)
z' = -x·sin(θ) + z·cos(θ)
```
Pitch (X-axis):
```
y' = y·cos(φ) - z·sin(φ)
z' = y·sin(φ) + z·cos(φ)
```
Roll (Z-axis):
```
x' = x·cos(ψ) - y·sin(ψ)
y' = x·sin(ψ) + y·cos(ψ)
```
### Culling
Points behind the camera (z ≤ 0.1) are set to `None` to prevent rendering artifacts and negative depth division.
## Performance
- **60 FPS** stable on most terrains
- **Megacity** (6400 vertices) - Largest terrain, still maintains 60 FPS (wireframe mesh only)
- Wireframe rendering and filled polygons from triangle partitions
## API Reference
### Renderer3D
Main renderer class that handles the 3D projection and rendering loop.
```python
from aiden3drenderer import Renderer3D
renderer = Renderer3D(
width=1200, # Window width in pixels
height=800, # Window height in pixels
fov=800 # Field of view (higher = less perspective)
)
renderer.run()
```
### Camera
Camera class for position and rotation control (automatically created by Renderer3D).
```python
from aiden3drenderer import Camera
# Access camera through renderer
renderer = Renderer3D()
camera = renderer.cam
# Camera attributes
camera.pos # [x, y, z] position
camera.facing # [yaw, pitch, roll] in radians
camera.speed # Movement speed (default: 0.5)
```
### register_shape Decorator
Register custom shape generators that appear in the renderer.
```python
@register_shape(name, key=None, is_animated=False)
def generate_function(grid_size=40, frame=0):
"""
Args:
name (str): Display name for the shape
key (pygame.K_*): Keyboard key to trigger shape (optional)
is_animated (bool): Whether shape changes over time
Returns:
list[list[float]]: grid_size x grid_size matrix of heights
"""
return matrix
```
## Package Structure
```
aiden3drenderer/
├── __init__.py # Package exports
├── renderer.py # Renderer3D class and projection
├── camera.py # Camera class for movement/rotation
└── shapes.py # 15+ built-in shape generators
examples/
├── basic_usage.py # Simple demo
└── custom_shape_example.py # Custom shape tutorial
```
## Development
### Running from Source
```bash
git clone https://github.com/AidenKielby/3D-mesh-Renderer
cd 3D-mesh-Renderer
pip install -e .
python examples/basic_usage.py
```
### Building the Package
```bash
pip install build twine
python -m build
python -m twine upload dist/*
```
## Credits
Created by Aiden. Most procedural generation functions created with AI assistance (the things like mountain and megacity). All the rest (rendering, projection, and camera code, etc.) written manually.
## License
Free to use and modify.
| text/markdown | Aiden | headstone.yt@gmail.com | null | null | null | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Multimedia :: Graphics :: 3D Rendering",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11"
] | [] | https://github.com/AidenKielby/3D-mesh-Renderer | null | >=3.9 | [] | [] | [] | [
"pygame>=2.6.0",
"pytest>=7.0; extra == \"dev\"",
"black; extra == \"dev\"",
"flake8; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.9 | 2026-02-20T17:35:32.277138 | aiden3drenderer-1.1.4.tar.gz | 23,495 | d7/25/6ca4e7e9a9a8f3f6eb398edcd1a2f881ef8ce3febd048c71775522bd1c3d/aiden3drenderer-1.1.4.tar.gz | source | sdist | null | false | 0565ddc6805888302edc7c606aae6923 | 9234d43875ba2987b5599783cdece8ee95190e0f8de1049f99d0466f1d752353 | d7256ca4e7e9a9a8f3f6eb398edcd1a2f881ef8ce3febd048c71775522bd1c3d | null | [] | 183 |
2.4 | ntsm | 0.1.4 | GIS Custom Modules package | ========================
NTSM - Vault & Utilities
========================
.. image:: https://img.shields.io/pypi/v/ntsm.svg
:target: https://pypi.org/project/ntsm/
:alt: PyPI Version
.. image:: https://img.shields.io/pypi/pyversions/ntsm.svg
:target: https://pypi.org/project/ntsm/
:alt: Supported Python Versions
.. image:: https://readthedocs.org/projects/ntsm/badge/?version=latest
:target: https://ntsm.readthedocs.io/en/latest/?badge=latest
:alt: Documentation Status
.. image:: https://img.shields.io/badge/License-MIT-yellow.svg
:target: https://opensource.org/licenses/MIT
:alt: License: MIT
.. image:: https://img.shields.io/badge/status-beta-orange.svg
:target: https://pypi.org/project/ntsm/
:alt: Project Status: Beta
The **NTSM** package serves as a central hub for GIS teams, providing a consistent and secure method for managing sensitive credentials across various platforms. Its primary objective is to eliminate hardcoded secrets and unify the connectivity patterns for frequently used APIs like ArcGIS Online or MSAL.
**Disclaimer & Attribution**
----------------------------
This project is an evolved library that incorporates various third-party code snippets and open-source logic. While primary development and architecture are steered by the author(s), many components have been refined, optimized, and adjusted using different AI agents to meet specific production requirements.
.. note::
This package is a **"transition and backward compatibility"** version and not yet a stable release; it should be used with appropriate caution.
Key Features
------------
* **Vault Security**: AES-256-GCM encryption with PBKDF2-HMAC-SHA512 key derivation.
* **Standardized Connections**: Unified interface for ArcGIS, MSAL and more.
* **Productivity Utilities**: Standardized logging, file handling, archiving, and more.
Installation
------------
Install the latest version from PyPI:
.. code-block:: bash
pip install ntsm
Quick Start
-----------
.. code-block:: python
from ntsm.conn import vault
# Initialize vault via environment variable
v = vault(key_env="GIS_KEY")
from ntsm.lib import setup_logging
logger = setup_logging("my_app", "./logs")
logger.info("Application started")
Module Examples
---------------
Secure Vault (aeadencrypt)
~~~~~~~~~~~~~~~~~~~~~~~~~~
Modern encryption for sensitive data.
.. code-block:: python
from ntsm.aeadencrypt import VaultCipher
v = VaultCipher(key_name="MY_KEY")
encrypted = v.encrypt("secret message")
decrypted = v.decrypt(encrypted)
# Legacy AES-128-CBC
from ntsm.aeadencrypt import VaultUtils
enc = VaultUtils.encrypt_text("hello", "secret")
Connections (conn)
~~~~~~~~~~~~~~~~~~
Easy access to common services.
.. code-block:: python
from ntsm.conn import agol, msal
# ArcGIS Online
gis = agol(url="https://nt.maps.arcgis.com", user="u", password="p")
# MSAL Email
mail = msal(tenant_id="...", client_id="...", client_email="...", client_secret="...")
Library Utilities (lib)
~~~~~~~~~~~~~~~~~~~~~~~
A wide range of helper functions and classes.
.. code-block:: python
from ntsm.lib import Files, Archive, FormatTime
# File & Folder management
Files.copy_dir("src", "dst")
Archive.make_zip("data")
# Time helpers
from datetime import datetime
t_str = FormatTime.to_str(datetime.now())
Package Structure
-----------------
* **ntsm.aeadencrypt**: ``VaultCipher`` (AES-256-GCM), ``VaultUtils`` (Legacy support).
* **ntsm.conn**: ``vault``, ``agol``, ``token``, ``msal``, and more.
* **ntsm.lib**: ``Email``, ``Files``, ``Archive``, ``setup_logging``, ``timer_wrap``, and more.
Full Documentation
------------------
Access documentation locally or online:
.. code-block:: bash
# Open the interactive documentation viewer
ntsmdocs
Online documentation is hosted at `Read the Docs <https://ntsm.readthedocs.io/>`_.
Contact & Support
-----------------
* **Author**: Adrian Coman
* **Email**: adrian.coman@nationaltrust.org.uk
* **Project Status**: Transition/Beta
| text/x-rst | null | Adrian Coman <adrian.coman@nationaltrust.org.uk> | null | null | MIT License
Copyright (c) 2024-present Adrian Coman
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. | ntsm, ntm, nts | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.10",
"Topic :: Software Development :: Build Tools"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"cryptography>=41.0.0",
"msal>=1.20.0",
"requests>=2.28.0",
"loguru>=0.7.0",
"sphinx>=5.0.0; extra == \"docs\"",
"sphinx-rtd-theme>=1.0.0; extra == \"docs\"",
"sphinx-autodoc-typehints>=1.0.0; extra == \"docs\"",
"nbsphinx>=0.8.0; extra == \"docs\"",
"sphinx-github-alerts>=1.0.0; extra == \"docs\"",
"ipython>=7.0.0; extra == \"docs\"",
"twine>=4.0.0; extra == \"dev\"",
"pytest>=7.0.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/adrian-coman/ntsm",
"Issues, https://github.com/adrian-coman/ntsm/issues",
"Documentation, https://ntsm.readthedocs.io/en/latest/"
] | twine/6.2.0 CPython/3.13.2 | 2026-02-20T17:35:21.754908 | ntsm-0.1.4.tar.gz | 38,227 | c3/9a/bfffa8f31c6fd22e74fc618e4e5a878225ce721a0238e503959dfa883baf/ntsm-0.1.4.tar.gz | source | sdist | null | false | caa8f1aafb8efcb777cd0c3593315b50 | e06f6e96289639d505366a4e45623291dcb69e19601b1c012e04e276ab3afdee | c39abfffa8f31c6fd22e74fc618e4e5a878225ce721a0238e503959dfa883baf | null | [
"LICENSE"
] | 201 |
2.4 | PlaywrightCapture | 1.36.9 | A simple library to capture websites using playwright | # Playwright Capture
Simple replacement for [splash](https://github.com/scrapinghub/splash) using [playwright](https://github.com/microsoft/playwright-python).
# Install
```bash
pip install playwrightcapture
```
# Usage
A very basic example:
```python
from playwrightcapture import Capture
async with Capture() as capture:
await capture.initialize_context()
entries = await capture.capture_page(url, max_depth_capture_time=90)
```
Entries is a dictionaries that contains (if all goes well) the HAR, the screenshot, all the cookies of the session, the URL as it is in the browser at the end of the capture, and the full HTML page as rendered.
# reCAPTCHA bypass
No blackmagic, it is just a reimplementation of a [well known technique](https://github.com/NikolaiT/uncaptcha3)
as implemented [there](https://github.com/Binit-Dhakal/Google-reCAPTCHA-v3-solver-using-playwright-python),
and [there](https://github.com/embium/solverecaptchas).
This modules will try to bypass reCAPTCHA protected websites if you install it this way:
```bash
pip install playwrightcapture[recaptcha]
```
This will install `requests`, `pydub` and `SpeechRecognition`. In order to work, `pydub`
requires `ffmpeg` or `libav`, look at the [install guide ](https://github.com/jiaaro/pydub#installation)
for more details.
`SpeechRecognition` uses the Google Speech Recognition API to turn the audio file into text (I hope you appreciate the irony).
| text/markdown | Raphaël Vinot | raphael.vinot@circl.lu | null | null | null | null | [
"Intended Audience :: Science/Research",
"Intended Audience :: Telecommunications Industry",
"Programming Language :: Python :: 3",
"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 :: Internet",
"Topic :: Security"
] | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"SpeechRecognition>=3.14.5; extra == \"recaptcha\"",
"aiohttp-socks>=0.11.0",
"aiohttp[speedups]>=3.13.3",
"async-timeout>=5.0.1; python_version < \"3.11\"",
"beautifulsoup4[charset-normalizer,lxml]>=4.14.3",
"dateparser>=1.3.0",
"dnspython<3.0.0,>=2.7.0",
"orjson<4.0.0,>=3.11.4",
"playwright>=1.58.0",
"playwright-stealth>=2.0.2",
"pure-magic-rs<0.4.0,>=0.3.2",
"pydub-ng>=0.2.0; extra == \"recaptcha\"",
"python-socks<3.0.0,>=2.7.1",
"rfc3161-client<2.0.0,>=1.0.4",
"setuptools>=82",
"typing-extensions<5.0.0,>=4.12.2; python_version < \"3.12\"",
"tzdata>=2025.3",
"w3lib>=2.4.0"
] | [] | [] | [] | [
"Issues, https://github.com/Lookyloo/PlaywrightCapture/issues",
"Repository, https://github.com/Lookyloo/PlaywrightCapture"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:35:11.951755 | playwrightcapture-1.36.9.tar.gz | 28,632 | 25/99/53cbacbafdcc7e5ea76f637f4ab5323ac341b2c21bcdd6555bd9076bff54/playwrightcapture-1.36.9.tar.gz | source | sdist | null | false | 30e5ed76dbf2fd55471a378c99b83e94 | 0a70b8898460ee30d97250bfb315d6223f11fbeeec5568077e38385001c4c1b9 | 259953cbacbafdcc7e5ea76f637f4ab5323ac341b2c21bcdd6555bd9076bff54 | BSD-3-Clause | [
"LICENSE"
] | 0 |
2.4 | async-rithmic | 1.5.9 | Python API Integration with Rithmic Protocol Buffer API | # Python Rithmic API
[](https://pypi.org/project/async-rithmic/)
[](https://github.com/rundef/async_rithmic/actions/workflows/ci.yml)
[](https://async-rithmic.readthedocs.io/en/latest/)
[](https://pypistats.org/packages/async-rithmic)
`async_rithmic` is a modern, high-performance Python API for the Rithmic trading platform.
Built with an async-first architecture, it enables robust, scalable access to Rithmic's Protocol Buffer interface for both live trading and real-time market data.
Designed with reliability and extensibility in mind, `async_rithmic` is a strong foundation for advanced trading systems requiring:
- Low-latency connectivity
- Real-time streaming capabilities
- Fault-tolerant, long-running operation
- Full control over order management and data handling
## ✨ Key Features
- ✅ **Python 3.10+ Compatibility**: Fully tested and supported.
- ⚡ **Async-first design**: Better scalability & responsiveness.
- 🛠️ **Robust architecture**: Built-in reconnection & fault-tolerance.
- [**Automatic reconnection**](https://async-rithmic.readthedocs.io/en/latest/connection.html#custom-reconnection-settings): Resilient to network interruptions with customizable backoff and retry logic.
- [**Automatic retries**](https://async-rithmic.readthedocs.io/en/latest/connection.html#custom-retry-settings): Configure how many times a slow request will be retried and for how long, making your client more resilient to network delays and backend slowness.
- 👥 **Multi-account support**
- 📊 **Historical + Live Time Bars**: Ideal for time-based strategies.
- 🎯 **Live Tick Data & Best Bid/Ask Streaming**: Fine-grained market data for real-time decision-making.
- 🪟 **Full Order Book (L2) Streaming**: Stream real-time depth of market (all bids/asks, multiple price levels) for advanced order flow analysis.
## 📦 Installation
```
pip install async_rithmic
```
## 📘 Documentation
👉 [See the official documentation for usage examples](https://async-rithmic.readthedocs.io/en/latest/)
## 🧪 Testing
To execute the tests, use the following command: `make tests`
## 📄 License
This project is licensed under the MIT License.
See [LICENSE](LICENSE) for details.
| text/markdown | Mickael Burguet | null | null | null | MIT | python, rithmic | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Topic :: Software Development :: Build Tools",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3 :: Only",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"pattern_kit>=2.0.0",
"websockets<15.0,>=11.0",
"protobuf<5,>=4.25.4",
"pytz>=2022.5",
"tzlocal>=5.2",
"check-manifest; extra == \"dev\"",
"coverage; extra == \"test\"",
"pytest; extra == \"test\""
] | [] | [] | [] | [
"Homepage, https://github.com/rundef/async_rithmic",
"Repository, https://github.com/rundef/async_rithmic",
"Issues, https://github.com/rundef/async_rithmic/issues"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-20T17:34:27.886522 | async_rithmic-1.5.9.tar.gz | 53,309 | 48/f4/5eb71ed1314231615d5d19f3b72741130ccde15a7b5091541887a2338dc7/async_rithmic-1.5.9.tar.gz | source | sdist | null | false | bccc4f8e32abb179e371e15b12a13665 | 69984d3d1148ff64bf2e7f7ddf63c15ab813fa236565bc9edfa2255b832eecf1 | 48f45eb71ed1314231615d5d19f3b72741130ccde15a7b5091541887a2338dc7 | null | [
"LICENSE"
] | 382 |
2.4 | flowmpl | 0.2.0 | Matplotlib design system and flow diagram renderer for analytical publications | # flowmpl
Matplotlib design system and flow diagram renderer for analytical publications.
Built for research notebooks that combine data visualization with process flow diagrams — the kind of work where you need both a consistent visual language across charts *and* clean auto-routed arrows between labeled boxes.
## Install
```bash
pip install flowmpl # core: matplotlib + numpy only
pip install flowmpl[charts] # + pandas (annotated_series, stacked_bar, etc.)
pip install flowmpl[maps] # + geopandas + requests (us_scatter_map)
pip install flowmpl[all] # everything
```
## Quick Start
```python
from flowmpl import COLORS, FONTS, flow_diagram
fig = flow_diagram(
nodes={
"a": ("Announce", 1.0, 1.0, COLORS["accent"], "#ffffff"),
"b": ("Permit", 3.0, 1.0, COLORS["neutral"], COLORS["text_dark"]),
"c": ("Build", 5.0, 1.0, COLORS["positive"], "#ffffff"),
},
edges=[
{"src": "a", "dst": "b", "label": "12–18 mo"},
{"src": "b", "dst": "c", "label": "24–36 mo"},
],
title="From announcement to operation",
)
fig.savefig("pipeline.png", dpi=150, bbox_inches="tight")
```
## Design System
`flowmpl` ships a complete design system extracted from a production research project:
| Token | Description |
|-------|-------------|
| `COLORS` | Semantic roles: `accent`, `positive`, `negative`, `neutral`, `muted`, `reference`, `background`, `text_dark`, `text_light` |
| `CONTEXT` | SWD gray — use for non-focus elements in gray+accent charts |
| `FONTS` | Font sizes for titles, labels, annotations, legends, captions |
| `FIGSIZE` | Named figure sizes: `standard`, `wide`, `tall`, `map` |
| `CATEGORICAL` | 8-color Paul Tol colorblind-safe palette |
| `FUEL_COLORS` | Energy generation types: solar, wind, battery, gas_cc, gas_ct, nuclear, hydro, coal… |
| `COMPANY_COLORS` | Hyperscaler tickers: MSFT, AMZN, GOOGL, META, NVDA, ORCL, AAPL, TSLA |
## Chart Functions
All functions return `matplotlib.Figure` objects.
```python
from flowmpl import (
annotated_series, # time series with annotations + fill
multi_panel, # multi-subplot from a single DataFrame
stacked_bar, # stacked bar for categorical breakdowns
waterfall_chart, # cost allocation / flow breakdowns
horizontal_bar_ranking, # ranked horizontal bars with highlights
)
```
## Helpers
```python
from flowmpl import (
focus_colors, # SWD gray+accent pattern: focus items colored, rest gray
legend_below, # place legend below axes (works with bbox_inches='tight')
annotate_point, # annotate a data point with arrow + text
reference_line, # labeled horizontal or vertical reference line
chart_title, # subtle left-aligned insight title (for standalone PNGs)
)
```
### `focus_colors()` example
```python
colors = focus_colors(
["MSFT", "AMZN", "GOOGL", "META"],
focus="AMZN",
color_map=COMPANY_COLORS,
)
# → ['#c0c0c0', '#ff9900', '#c0c0c0', '#c0c0c0']
```
## Flow Diagram
`flow_diagram()` renders labeled boxes connected by auto-routed arrows. It handles:
- **Auto-routing**: chooses straight or elbow connections based on source/destination geometry
- **Face overrides**: explicit `exit`/`entry` keys bypass the heuristic for complex layouts
- **Auto-spacing**: adjusts vertical spacing to prevent label overlap
- **Face spreading**: distributes multiple edges from the same face to avoid overlaps
### Node format
```python
nodes = {
"key": (label, cx, cy, fill_color, text_color),
}
```
- `cx`, `cy`: center coordinates in abstract units (the renderer scales to fit)
- Sizes auto-scaled; override with `node_width` / `node_height` params
### Edge format
```python
edges = [
{"src": "a", "dst": "b"}, # basic
{"src": "a", "dst": "b", "label": "2 years"}, # with label
{"src": "a", "dst": "b", "dashed": True}, # dashed line
{"src": "a", "dst": "b", "color": "#888"}, # custom color
{"src": "a", "dst": "b", "exit": "top", "entry": "left"}, # face override
{"src": "a", "dst": "b", "exit": "bottom", "entry": "left"}, # force exit face
]
```
### Routing heuristic
The auto-router uses the vector between node centers:
| Condition | Route style |
|-----------|-------------|
| `\|vy\| < 0.25 \* \|vx\|` | Near-horizontal — straight line |
| `\|vx\| < 0.25 \* \|vy\|` | Near-vertical — straight line |
| `\|vy\| < 0.75 \* \|vx\|` | Primarily-horizontal — exit top/bottom, enter side |
| else | Primarily-vertical — exit side, enter top/bottom |
Use explicit `exit`/`entry` overrides when the heuristic produces overlapping arrows
from the same face (e.g., a root node with multiple connections at different angles).
### T-layout example (face overrides)
```python
fig = flow_diagram(
nodes={
"r": ("Root", 1.0, 1.5, COLORS["accent"], "#ffffff"),
"a": ("Top", 4.5, 3.0, COLORS["positive"], "#ffffff"),
"m": ("Middle", 4.5, 1.5, COLORS["neutral"], COLORS["text_dark"]),
"b": ("Bottom", 4.5, 0.0, CONTEXT, COLORS["text_dark"]),
},
edges=[
{"src": "r", "dst": "a", "exit": "top", "entry": "left"},
{"src": "r", "dst": "m"}, # straight, no override needed
{"src": "r", "dst": "b", "exit": "bottom", "entry": "left"},
],
title="Three destinations from one source",
)
```
Without the face overrides, all three arrows would exit from `r`'s right face and overlap.
With `exit="top"` and `exit="bottom"`, each arrow leaves from a different face.
## Map
```python
from flowmpl import us_scatter_map
import matplotlib.patches as mpatches
fig = us_scatter_map(
lats=[37.7, 40.7, 41.8],
lons=[-122.4, -74.0, -87.6],
colors=["#e74c3c", "#3498db", "#2ecc71"],
sizes=[100, 150, 80],
title="Three cities",
legend_handles=[
mpatches.Patch(color="#e74c3c", label="San Francisco"),
mpatches.Patch(color="#3498db", label="New York"),
mpatches.Patch(color="#2ecc71", label="Chicago"),
],
)
```
State boundary shapefiles are downloaded from the US Census Bureau on first use and
cached in the package directory.
## License
MIT
| text/markdown | null | null | null | null | MIT | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"matplotlib>=3.7",
"numpy>=1.24",
"geopandas>=1.0; extra == \"all\"",
"pandas>=2.0; extra == \"all\"",
"requests>=2.31; extra == \"all\"",
"pandas>=2.0; extra == \"charts\"",
"dlt[duckdb]>=1.0; extra == \"dev\"",
"geopandas>=1.0; extra == \"dev\"",
"marimo>=0.10; extra == \"dev\"",
"mypy>=1.8; extra == \"dev\"",
"pandas>=2.0; extra == \"dev\"",
"requests>=2.31; extra == \"dev\"",
"ruff>=0.3; extra == \"dev\"",
"dlt[duckdb]>=1.0; extra == \"examples\"",
"marimo>=0.10; extra == \"examples\"",
"geopandas>=1.0; extra == \"maps\"",
"requests>=2.31; extra == \"maps\""
] | [] | [] | [] | [] | uv/0.8.0 | 2026-02-20T17:34:21.469449 | flowmpl-0.2.0.tar.gz | 2,519,765 | 87/d7/bbe78a83669eab528c7df947173f1b4fea2dab51841b313cf688a378e818/flowmpl-0.2.0.tar.gz | source | sdist | null | false | 8eddabedb9f8ea6a0afb1c5b3e0d7c54 | 4176d0c6f42d22dc05ab02b7c9e375f36311be0b54bd27642fcffaf019d598c9 | 87d7bbe78a83669eab528c7df947173f1b4fea2dab51841b313cf688a378e818 | null | [] | 186 |
2.4 | langchain-trigger-server | 0.3.40 | Generic event-driven triggers framework | # LangChain Trigger Server
Framework for developing triggers for use in the LangSmith Agent Builder | text/markdown | Open Agent Platform Team | null | null | null | MIT | agents, events, triggers, webhooks | [
"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"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"apscheduler>=3.10.0",
"cachetools>=5.0.0",
"croniter>=1.4.0",
"cryptography>=3.0.0",
"fastapi>=0.100.0",
"httpx>=0.24.0",
"langchain-auth>=0.0.1",
"langgraph-sdk>=0.3.4",
"pydantic>=2.0.0",
"python-multipart>=0.0.6",
"structlog>=24.0.0",
"supabase>=2.0.0",
"uvicorn[standard]>=0.20.0",
"black>=23.0.0; extra == \"dev\"",
"mypy>=1.0.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest>=7.0.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/langchain-ai/open-agent-platform",
"Repository, https://github.com/langchain-ai/open-agent-platform"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:33:59.178291 | langchain_trigger_server-0.3.40.tar.gz | 84,060 | e6/09/acd150a00b704b78464c4525a4eadde27668c2802df9e4d2e2037b1b53e0/langchain_trigger_server-0.3.40.tar.gz | source | sdist | null | false | b36f79f9ad6ed26989542d7ac8edb4f9 | f2e45cb0fd389e2fd50dff8c2d579767d1682013a0668a71bba3e341d43caaef | e609acd150a00b704b78464c4525a4eadde27668c2802df9e4d2e2037b1b53e0 | null | [] | 181 |
2.4 | laakhay-ta | 0.2.8 | Stateless Technical Analysis Library built with ♥︎ by Laakhay | # Laakhay TA
A stateless technical analysis toolkit built on immutable data structures, explicit indicator metadata, and algebraic composition. Provides a domain-specific language (DSL) for expressing trading strategies with support for multi-source data (OHLCV, trades, orderbook, liquidations), filtering, aggregation, time-shifted queries, and **explicit indicator input sources**.
## Core Principles
- **Immutable & Stateless**: All data structures (`Bar`, `OHLCV`, `Series`, `Dataset`) are immutable with timezone-aware timestamps and Decimal precision
- **Registry-Driven**: Indicators expose schemas, enforce parameters, and can be extended at runtime
- **Algebraic Composition**: Indicators, literals, and sources compose into expression DAGs with dependency inspection
- **Multi-Source Support**: Access data from OHLCV, trades, orderbook, and liquidation sources
- **Explicit Input Sources**: Indicators can operate on arbitrary series specified in expressions
- **Requirement Planning**: Expression planner computes data requirements, lookbacks, and serializes them for backend services
## Installation
```bash
uv pip install laakhay-ta
```
**Requirements**: Python 3.12+
## Quick Start
### Basic Indicator Usage
```python
from datetime import UTC, datetime
from decimal import Decimal
import laakhay.ta as ta
from laakhay.ta import dataset
from laakhay.ta.core import OHLCV, align_series
# Create OHLCV data
ohlcv = OHLCV(
timestamps=(
datetime(2024, 1, 1, tzinfo=UTC),
datetime(2024, 1, 2, tzinfo=UTC),
datetime(2024, 1, 3, tzinfo=UTC),
),
opens=(Decimal("100"), Decimal("101"), Decimal("103")),
highs=(Decimal("105"),) * 3,
lows=(Decimal("99"),) * 3,
closes=(Decimal("101"), Decimal("102"), Decimal("104")),
volumes=(Decimal("1000"), Decimal("1100"), Decimal("1150")),
is_closed=(True,) * 3,
symbol="BTCUSDT",
timeframe="1h",
)
market = dataset(ohlcv)
# Create indicator handles
sma_fast = ta.indicator("sma", period=2)
sma_slow = ta.indicator("sma", period=3)
# Evaluate on dataset
fast_series = sma_fast(market)
slow_series = sma_slow(market)
# Align and compute
fast, slow = align_series(fast_series, slow_series, how="inner", fill="none",
symbol="BTCUSDT", timeframe="1h")
spread = fast - slow
print(spread.values) # Decimal results
```
### Expression Composition
```python
# Compose indicators algebraically
signal = sma_fast - sma_slow
result = signal.run(market)
# Inspect requirements
print(signal.describe())
requirements = signal.requirements()
print(requirements.fields) # Required data fields
```
## Indicator Expression Inputs
**New Feature**: Indicators can now operate on explicit series specified in expressions, enabling operations on arbitrary data sources.
For details on expression syntax, aliases (`mean`, `median`), and `lookback` usage, see the [Expression Language Guide](docs/expression_language.md).
### Explicit Source Syntax
```python
from laakhay.ta.expr.dsl import compile_expression
# OHLCV sources
expr = compile_expression("sma(BTC.price, period=20)")
expr = compile_expression("sma(BTC.volume, period=10)")
# Non-OHLCV sources (trades, orderbook, liquidations)
expr = compile_expression("sma(BTC.trades.volume, period=20)")
expr = compile_expression("sma(binance.BTC.orderbook.imbalance, period=10)")
expr = compile_expression("sma(BTC.liquidation.volume, period=5)")
# Nested expressions
expr = compile_expression("sma(BTC.high + BTC.low, period=5)")
expr = compile_expression("rsi(BTC.trades.avg_price, period=14)")
# Evaluate expressions
result = expr.run(dataset)
```
### Programmatic API
```python
from laakhay.ta.core import Series
from decimal import Decimal
# Create a custom series
custom_series = Series(
timestamps=(datetime(2024, 1, 1, tzinfo=UTC),),
values=(Decimal("100"),),
symbol="BTCUSDT",
timeframe="1h"
)
# Use as input_series parameter
sma_handle = ta.sma(input_series=custom_series, period=20)
result = sma_handle.run(market)
```
### Backward Compatibility
Traditional syntax continues to work:
```python
# These all work as before
expr = compile_expression("sma(20)") # Uses default 'close' field
expr = compile_expression("sma(period=20)") # Keyword arguments
expr = compile_expression("rsi(14)") # RSI with default close
```
## Multi-Source Expressions
Access data from multiple sources using attribute chains:
### OHLCV Data
```python
from laakhay.ta.expr.dsl import parse_expression_text, compile_expression
# Price and volume
expr = parse_expression_text("BTC/USDT.price > 50000")
expr = parse_expression_text("BTC/USDT.1h.volume > 1000000")
# Multiple timeframes
expr = parse_expression_text("BTC/USDT.1h.price > BTC/USDT.4h.price")
```
### Trade Aggregations
```python
# Volume and count
expr = parse_expression_text("BTC/USDT.trades.volume > 1000000")
expr = parse_expression_text("BTC/USDT.trades.count > 100")
# Filtered aggregations
expr = parse_expression_text("BTC/USDT.trades.filter(amount > 1000000).count > 10")
expr = parse_expression_text("BTC/USDT.trades.sum(amount) > 50000000")
expr = parse_expression_text("BTC/USDT.trades.avg(price) > 50000")
# Aggregation properties
expr = parse_expression_text("BTC/USDT.trades.count > 100")
```
### Orderbook Data
```python
# Imbalance and spread
expr = parse_expression_text("BTC/USDT.orderbook.imbalance > 0.5")
expr = parse_expression_text("binance.BTC.orderbook.spread_bps < 10")
expr = parse_expression_text("BTC/USDT.orderbook.pressure > 0.7")
# Depth analysis
expr = parse_expression_text("BTC/USDT.orderbook.bid_depth > BTC/USDT.orderbook.ask_depth")
```
### Time-Shifted Queries
```python
# Historical comparisons
expr = parse_expression_text("BTC/USDT.price.24h_ago < BTC/USDT.price")
expr = parse_expression_text("BTC/USDT.volume.change_pct_24h > 10")
expr = parse_expression_text("BTC/USDT.price.change_1h > 0")
```
### Exchange and Timeframe Qualifiers
```python
# Exchange-specific data
expr = parse_expression_text("binance.BTC.price > 50000")
expr = parse_expression_text("bybit.BTC.1h.trades.volume > 1000000")
# Timeframe specification
expr = parse_expression_text("BTC.1h.price > BTC.4h.price")
expr = parse_expression_text("binance.BTC.1h.orderbook.imbalance")
```
## Expression Planning and Requirements
The planner computes data requirements, lookbacks, and dependencies:
```python
from laakhay.ta.expr.planner import plan_expression
from laakhay.ta.expr.dsl import compile_expression
# Compile expression
expr = compile_expression("sma(BTC.trades.volume, period=20) > 1000000")
plan = plan_expression(expr._node)
# Access requirements
print(plan.requirements.data_requirements) # Data sources needed
print(plan.requirements.required_sources) # ['trades']
print(plan.requirements.required_exchanges) # ['binance'] if specified
print(plan.requirements.fields) # Field requirements
# Serialize for backend
plan_dict = plan.to_dict()
```
### Capability Manifest
```python
from laakhay.ta.expr.planner import generate_capability_manifest
manifest = generate_capability_manifest()
print(manifest["sources"]) # Available sources and fields
print(manifest["indicators"]) # Available indicators with metadata
print(manifest["operators"]) # Available operators
```
## Indicator Registry
### Inspecting Indicators
```python
# Get indicator schema
schema = ta.describe_indicator("sma")
print(schema.params) # Parameter definitions
print(schema.metadata) # Metadata (lookback, fields, etc.)
print(schema.description) # Documentation
# Check input field metadata
metadata = schema.metadata
print(metadata.input_field) # Default input field ('close')
print(metadata.input_series_param) # Parameter name for override ('input_series')
```
### Registering Custom Indicators
```python
from laakhay.ta import SeriesContext, register, Series, Price
@register("mid_price", description="Mid price indicator")
def mid_price(ctx: SeriesContext) -> Series[Price]:
"""Compute mid price from high and low."""
return (ctx.high + ctx.low) / 2
# Use custom indicator
mid = ta.indicator("mid_price")
result = mid(market)
```
### Indicator Metadata
Indicators declare their metadata including:
- **Required fields**: Fields needed from context (e.g., `('close',)`)
- **Optional fields**: Additional fields that may be used
- **Lookback parameters**: Parameters that affect lookback window
- **Input field**: Default input field (e.g., `'close'`)
- **Input series parameter**: Parameter name for explicit input override
## Streaming and Real-Time Updates
```python
from laakhay.ta.stream import Stream
from laakhay.ta.core.bar import Bar
# Create stream
stream = Stream()
stream.register("sma2", ta.indicator("sma", period=2)._to_expression())
# Update with new bars
base = datetime(2024, 1, 1, tzinfo=UTC)
stream.update_ohlcv("BTCUSDT", "1h",
Bar.from_raw(base, 100, 105, 99, 101, 1000, True))
update = stream.update_ohlcv("BTCUSDT", "1h",
Bar.from_raw(base + timedelta(hours=1), 101, 106, 100, 102, 1100, True))
print(update.transitions[0].value) # Updated indicator value
```
## I/O and Data Loading
### CSV Import/Export
```python
# Load from CSV
ohlcv = ta.from_csv("btc_1h.csv", symbol="BTCUSDT", timeframe="1h")
market = dataset(ohlcv)
# Export to CSV
ta.to_csv(ohlcv, "btc_out.csv")
```
### Dataset Construction
```python
from laakhay.ta import dataset
# Single series
market = dataset(ohlcv)
# Multiple series
market = dataset(btc_ohlcv, eth_ohlcv)
# With trades/orderbook data
market = dataset(ohlcv, trades_series, orderbook_series)
```
## Expression Validation and Preview
```python
from laakhay.ta.expr.runtime import validate, preview
# Validate expression syntax and requirements
expr = compile_expression("sma(BTC.price, period=20) > sma(BTC.price, period=50)")
result = validate(expr)
if result.valid:
print("Expression is valid")
print(result.requirements)
else:
print(result.errors)
# Preview expression execution
preview_result = preview(expr, bars=your_bars, symbol="BTC/USDT", timeframe="1h")
print(preview_result.triggers)
print(preview_result.values)
```
## Advanced Features
### Complex Expressions
```python
# Multiple indicators with explicit sources
expr = compile_expression(
"sma(BTC.price, period=20) > sma(BTC.volume, period=10) & "
"rsi(BTC.trades.avg_price, period=14) < 30"
)
# Nested operations
expr = compile_expression(
"sma(BTC.high + BTC.low, period=5) > "
"sma(BTC.trades.volume, period=20)"
)
# Time-shifted comparisons
expr = compile_expression(
"sma(BTC.price, period=20) > BTC.price.24h_ago"
)
```
### Expression Serialization
```python
from laakhay.ta.expr.dsl.nodes import expression_to_dict, expression_from_dict
# Serialize expression
expr = parse_expression_text("sma(BTC.price, period=20)")
serialized = expression_to_dict(expr)
# Deserialize
restored = expression_from_dict(serialized)
```
## Architecture
### Core Components
| Component | Responsibility |
|-----------|---------------|
| **Core Data** | Immutable series (`Bar`, `OHLCV`, `Series`) with timezone-aware timestamps |
| **Expression DSL** | Parser and AST for strategy expressions |
| **Indicator Registry** | Metadata-driven indicator system with schema validation |
| **Planner** | Computes data requirements, lookbacks, and dependencies |
| **Evaluator** | Executes expression graphs on datasets |
| **Streaming** | Real-time update processing |
### Expression Graph
Expressions compile to a directed acyclic graph (DAG) where:
- **Nodes** represent operations (indicators, arithmetic, comparisons)
- **Edges** represent data dependencies
- **Source nodes** represent data requirements (OHLCV, trades, etc.)
- **Indicator nodes** can have explicit input expressions as dependencies
### Data Flow
1. **Parse**: Expression text → AST nodes
2. **Compile**: AST nodes → Expression graph
3. **Plan**: Expression graph → Requirements and dependencies
4. **Evaluate**: Expression graph + Dataset → Results
## Development
```bash
# Clone repository
git clone https://github.com/laakhay/ta
cd ta
# Setup environment
uv sync --extra dev
# Format code
uv run ruff format laakhay/
# Lint
uv run ruff check --fix laakhay/
# Run tests
PYTHONPATH=$PWD uv run pytest tests/ -v --tb=short
```
## License
MIT License
| text/markdown | null | Laakhay Corporation <laakhay.corp@gmail.com> | null | null | MIT | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"build>=1.0.0; extra == \"dev\"",
"pyright>=1.1.406; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest-cov>=7.0.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"twine>=5.0.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://laakhay.com",
"Repository, https://github.com/laakhay/ta",
"Issues, https://github.com/laakhay/ta/issues"
] | uv/0.9.4 | 2026-02-20T17:33:52.357906 | laakhay_ta-0.2.8.tar.gz | 117,651 | 8e/7b/cc5ec3248a23a32c1d772613c6be8c2752f77edec1bfe718f3ac3915e7a0/laakhay_ta-0.2.8.tar.gz | source | sdist | null | false | 7e4d3b1900ea490b0cbf14ae7918bbbb | 1421239043fcd1670723c7a2f454f931b49a6c65fbfb772a42430df33661c39f | 8e7bcc5ec3248a23a32c1d772613c6be8c2752f77edec1bfe718f3ac3915e7a0 | null | [
"LICENSE"
] | 191 |
2.4 | e3sm-quickview | 1.3.3 | An application to explore/analyze data for atmosphere component for E3SM | # QuickView
[](https://github.com/ayenpure/QuickView/actions/workflows/test.yml)
[](https://github.com/ayenpure/QuickView/actions/workflows/package-and-release.yml)
**EAM QuickView** is an open-source, interactive visualization tool
designed for scientists working with the atmospheric component of the
[Energy Exascale Earth System Model (E3SM)](https://e3sm.org/),
known as the E3SM Atmosphere Model (EAM).
Its Python- and [Trame](https://www.kitware.com/trame/)-based
Graphical User Interface (GUI) provides
intuitive access to [ParaView](https://www.paraview.org/)'s
powerful analysis and visualization capabilities, without the steep learning curve.
## Key Features
- Intuitive, minimalist interface tailored for atmospheric modeling.
- Multi-variable visualization with drag-and-drop layout.
- Persistent sessions - pick up where you left off.
- Support for EAM v2, v3, and upcoming v4 output formats.
## Quick Start
- Install and launch the app for [end users](docs/setup/for_end_users.md)
or [app developers](docs/setup/for_app_developers.md).
- Download connectivity files of EAM's cubed-sphere grids from
[Zenodo](https://doi.org/10.5281/zenodo.16908566).
- Optional: download [sample simulation output](https://zenodo.org/records/16922607)
to test the app.
- For EAMv2 and v3 developers and users: if your simulation data files
are *not* the original files written out by the model,
i.e., if your files were generated by NCO, CDO, etc.
check QuickView's [data format requirements](docs/userguide/data_requirements.md).
- For EAMxx developers and users: EAMxx's most recent output format
changes might not have been accommodated. If your run into problems
opening your data files, please check the
[Issues tab on GitHub](https://github.com/ayenpure/QuickView/issues) and
open a new issue if needed.
More detailed descriptions of how to download, install, and use QuickView
can be found in the [documentation](https://quickview.readthedocs.io/en/latest/).
## Project Background
QuickView is developed by [Kitware, Inc.](https://www.kitware.com/) in
collaboration with
[Pacific Northwest National Laboratory](https://www.pnnl.gov/), supported by the
U.S. Department of Energy's
[ASCR](https://www.energy.gov/science/ascr/advanced-scientific-computing-research)
and
[BER](https://www.energy.gov/science/ber/biological-and-environmental-research)
programs via [SciDAC](https://www.scidac.gov/).
### Contributors
- **Lead Developer**: Abhishek Yenpure (Kitware, Inc.)
- **Key Contributors**: Berk Geveci, Sebastien Jourdain (Kitware, Inc.); Hui
Wan, Kai Zhang (PNNL)
## License
Apache Software License - see [LICENSE](LICENSE) file for details.
| text/markdown | Kitware Inc. | null | null | null | Apache Software License | Application, Framework, Interactive, Python, Web | [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"License :: OSI Approved :: Apache Software License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Topic :: Software Development :: Libraries :: Application Frameworks",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"netcdf4>=1.6.5",
"pillow",
"pyproj>=3.6.1",
"trame-components",
"trame-dataclass>=1.2",
"trame-tauri>=0.6.2",
"trame-vtk>=2.10",
"trame-vuetify>=3.1",
"trame>=3.12",
"jupyter-server-proxy>=4.0.0; extra == \"jupyter\"",
"pyinstaller; extra == \"tauri\"",
"trame-grid-layout>=1.0.3; extra == \"vue2\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:33:45.278502 | e3sm_quickview-1.3.3.tar.gz | 1,556,842 | ab/6c/c0653bcf7a5cd4fee403ef14653c6130e91e5d60c8dffba1a325cf24260a/e3sm_quickview-1.3.3.tar.gz | source | sdist | null | false | 9c618d91ee81bfd46e20519ab26738d0 | 6993f9e593246a2f01dac394cfa49ad45a843c9fd3f3aa8a254c3bceaa4c3fdc | ab6cc0653bcf7a5cd4fee403ef14653c6130e91e5d60c8dffba1a325cf24260a | null | [
"LICENSE"
] | 188 |
2.4 | dbt-subprocess-plugin | 0.1.0 | dbt plugin to add Python's subprocess module to dbt's `modules` context attribute | # dbt-subprocess-plugin
This is a [dbt plugin][] to add Python's [subprocess][] module to dbt's [`modules` context][modules] attribute.
[dbt-plugin]: https://github.com/dbt-labs/dbt-core/blob/fa96acb15f79ae4f10b1d78f311f5ef2f4ed645e/core/dbt/plugins/manager.py
[subprocess]: https://docs.python.org/3/library/subprocess.html
[modules]: https://docs.getdbt.com/reference/dbt-jinja-functions/modules
## Usage
1. Install `dbt-subprocess-plugin` via PyPI into the same Python environment as dbt itself.
2. Start using it!
## Example
```console
$ dbt compile -q --inline '{{ modules.subprocess.check_output(["echo", "Hello from subprocess!"]) }}'
Hello from subprocess!
```
| text/markdown | null | Tim Vergenz <vergenzt@gmail.com> | null | null | null | null | [] | [] | null | null | >=3.8 | [] | [] | [] | [
"dbt-core>=1.6"
] | [] | [] | [] | [] | uv/0.9.18 {"installer":{"name":"uv","version":"0.9.18","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-20T17:33:44.290575 | dbt_subprocess_plugin-0.1.0.tar.gz | 211,626 | bd/05/994fea493ae06eaac72299c4e093ba330b2162e3e59b45f9e8bbaaa87fcd/dbt_subprocess_plugin-0.1.0.tar.gz | source | sdist | null | false | e0a0769d7f71f34ba2080e16a65e896f | 8070992d5bb3a7808c1b31dbbc18b2e1871d6b28eab48393d9b67c932310690a | bd05994fea493ae06eaac72299c4e093ba330b2162e3e59b45f9e8bbaaa87fcd | null | [] | 197 |
2.4 | relationalai | 0.14.0 | RelationalAI Library and CLI | # The RelationalAI Python Library
The Python library for building and querying knowledge graphs with RelationalAI.
For more information, visit our documentation at [https://relational.ai/docs](https://relational.ai/docs).
| text/markdown | null | RelationalAI <support@relational.ai> | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"aiohttp",
"click==8.2.1",
"colorama",
"cryptography",
"gravis",
"inquirerpy",
"lqp==0.2.3",
"nicegui>=3.7.0",
"numpy<2",
"opentelemetry-api",
"opentelemetry-exporter-otlp-proto-http",
"opentelemetry-sdk",
"packaging",
"pandas",
"pyarrow",
"pyjwt",
"requests",
"rich",
"snowflake-connector-python[secure-local-storage]",
"snowflake-snowpark-python>=1.38.0",
"toml",
"tomlkit",
"typing-extensions",
"wcwidth",
"websockets",
"argcomplete; extra == \"dev\"",
"build; extra == \"dev\"",
"coverage; extra == \"dev\"",
"duckdb; extra == \"dev\"",
"faker; extra == \"dev\"",
"hupper; extra == \"dev\"",
"hypothesis; extra == \"dev\"",
"jupyter; extra == \"dev\"",
"logscope; extra == \"dev\"",
"pandas-stubs; extra == \"dev\"",
"pexpect; extra == \"dev\"",
"pip-tools; extra == \"dev\"",
"polars; extra == \"dev\"",
"prompt-toolkit; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest-mock; extra == \"dev\"",
"pytest-snapshot; extra == \"dev\"",
"pytest-timeout; extra == \"dev\"",
"ruff; extra == \"dev\"",
"scipy; extra == \"dev\"",
"sqlite-utils; extra == \"dev\"",
"sympy; extra == \"dev\"",
"tablescope; extra == \"dev\"",
"watchdog; extra == \"dev\"",
"dataclasses-json; extra == \"ea\"",
"owlready2; extra == \"ea\"",
"parameterized; extra == \"ea\"",
"pysmt; extra == \"ea\"",
"simple-ddl-parser; extra == \"ea\"",
"xmltodict; extra == \"ea\"",
"rai-sdk>=0.7.5; extra == \"legacy\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.14 | 2026-02-20T17:33:33.166850 | relationalai-0.14.0.tar.gz | 1,313,008 | 56/ae/ea9316c8b5d1306c11c24ddf566d1d313c6c9944030610cf21bd6f2f18c1/relationalai-0.14.0.tar.gz | source | sdist | null | false | bece66948caa92b1935f9f3d81a9430b | 48382d7452af9edf67fad034b66ac71bdc83e5c454fe68d223547ad16a0ac589 | 56aeea9316c8b5d1306c11c24ddf566d1d313c6c9944030610cf21bd6f2f18c1 | null | [
"LICENSE"
] | 376 |
2.4 | asyncer | 0.0.15 | Asyncer, async and await, focused on developer experience. | <p align="center">
<a href="https://asyncer.tiangolo.com"><img src="https://asyncer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" alt="Asyncer"></a>
</p>
<p align="center">
<em>Asyncer, async and await, focused on developer experience.</em>
</p>
<p align="center">
<a href="https://github.com/fastapi/asyncer/actions?query=workflow%3ATest+event%3Apush+branch%3Amain" target="_blank">
<img src="https://github.com/fastapi/asyncer/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Test">
</a>
<a href="https://github.com/fastapi/asyncer/actions?query=workflow%3APublish" target="_blank">
<img src="https://github.com/fastapi/asyncer/actions/workflows/publish.yml/badge.svg" alt="Publish">
</a>
<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/asyncer" target="_blank">
<img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/asyncer.svg" alt="Coverage">
<a href="https://pypi.org/project/asyncer" target="_blank">
<img src="https://img.shields.io/pypi/v/asyncer?color=%2334D058&label=pypi%20package" alt="Package version">
</a>
</p>
---
**Documentation**: <a href="https://asyncer.tiangolo.com" target="_blank">https://asyncer.tiangolo.com</a>
**Source Code**: <a href="https://github.com/fastapi/asyncer" target="_blank">https://github.com/fastapi/asyncer</a>
---
**Asyncer** is a small library built on top of <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>.
**Asyncer** has a small number of utility functions that allow working with `async`, `await`, and concurrent code in a more convenient way under my (<a href="https://twitter.com/tiangolo" class="external-link" target="_blank">@tiangolo - Sebastián Ramírez</a>) very opinionated and subjective point of view.
The main goal of **Asyncer** is to improve **developer experience** by providing better support for **autocompletion** and **inline errors** in the editor, and **more certainty** that the code is **bug-free** by providing better support for type checking tools like **mypy**.
**Asyncer** also tries to improve **convenience** and simplicity when working with **async** code **mixed** with regular <abbr title="synchronous code, code that is not async">**blocking code**</abbr>, allowing to use them together in a simpler way... again, under my very **subjective** point of view.
## Can I Use It?
Yes 🎉 (but continue reading).
This is a very small library, there are things that can change and improve in the future.
If you use it, **pin the exact Asyncer version** for your project, to make sure it all works.
Have **tests** for your project (as you should, anyway). And **upgrade the version** once you know that the new version continues to work correctly.
Still, it's **just 4 functions**, so there's not much to change, if you had to refactor your code to update something it would not be much.
And if you don't want to add `asyncer` as a dependency to your project, you can also just copy the main file and try out those functions, it's quite small (but in that case you won't get updates easily).
## Requirements
As **Asyncer** is based on **AnyIO** it will be also installed automatically when you install **Asyncer**.
## Installation
<div class="termy">
```console
$ pip install asyncer
---> 100%
Successfully installed asyncer anyio
```
</div>
## How to Use
You can read more about each of the use cases and utility functions in **Asyncer** in the <a href="https://asyncer.tiangolo.com/tutorial/" class="external-link" target="_blank">tutorial</a>.
As a sneak preview of one of the utilities, you can **call sync code from async code** using `asyncify()`:
```Python
import time
import anyio
from asyncer import asyncify
def do_sync_work(name: str):
time.sleep(1)
return f"Hello, {name}"
async def main():
message = await asyncify(do_sync_work)(name="World")
print(message)
anyio.run(main)
```
**Asyncer**'s `asyncify()` will use AnyIO underneath to do *the smart thing*, avoid blocking the main **async** event loop, and run the **sync**/blocking function in a **worker thread**.
### Editor Support
Everything in **Asyncer** is designed to get the best **developer experience** possible, with the best editor support.
* **Autocompletion** for function arguments:
<img class="shadow" src="https://asyncer.tiangolo.com/img/tutorial/asyncify/image01.png">
* **Autocompletion** for return values:
<img class="shadow" src="https://asyncer.tiangolo.com/img/tutorial/asyncify/image02.png">
* **Inline errors** in editor:
<img class="shadow" src="https://asyncer.tiangolo.com/img/tutorial/soonify/image02.png">
* Support for tools like **mypy**, that can help you verify that your **code is correct**, and prevent many bugs.
## License
This project is licensed under the terms of the [MIT license](https://github.com/fastapi/asyncer/blob/main/LICENSE).
| text/markdown | null | Sebastián Ramírez <tiangolo@gmail.com> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Framework :: AsyncIO",
"Framework :: Trio",
"Intended Audience :: Developers",
"Intended Audience :: Education",
"Intended Audience :: Information Technology",
"Intended Audience :: Science/Research",
"Intended Audience :: System Administrators",
"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 :: Internet",
"Typing :: Typed"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"anyio<5.0,>=3.4.0",
"sniffio>=1.1",
"typing_extensions>=4.12.0; python_version < \"3.15\""
] | [] | [] | [] | [
"Homepage, https://github.com/fastapi/asyncer",
"Documentation, https://asyncer.tiangolo.com",
"Repository, https://github.com/fastapi/asyncer",
"Issues, https://github.com/fastapi/asyncer/issues",
"Changelog, https://asyncer.tiangolo.com/release-notes/"
] | 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-20T17:32:35.709230 | asyncer-0.0.15.tar.gz | 20,090 | 7a/d0/e71744250a22bf358095dbc471ecd4c453bd666f789f2b14cf3ead50fbd8/asyncer-0.0.15.tar.gz | source | sdist | null | false | d36ae0a896a3fb30c13cff77a19ff868 | 339c8493a2be8f188e4bf741019252f7c344e2a78c83a37913dc7832c47f4309 | 7ad0e71744250a22bf358095dbc471ecd4c453bd666f789f2b14cf3ead50fbd8 | MIT | [
"LICENSE"
] | 10,859 |
2.2 | certora-cli-alpha-master | 20260220.17.32.693288 | Runner for the Certora Prover | Commit bd9275d. Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
| text/markdown | Certora | support@certora.com | null | null | GPL-3.0-only | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
"Operating System :: OS Independent"
] | [] | https://pypi.org/project/certora-cli-alpha-master | null | >=3.9 | [] | [] | [] | [
"click",
"json5",
"pycryptodome",
"requests",
"rich",
"sly",
"tabulate",
"tqdm",
"StrEnum",
"jinja2",
"wcmatch",
"typing_extensions"
] | [] | [] | [] | [
"Documentation, https://docs.certora.com/en/latest/",
"Source, https://github.com/Certora/CertoraProver"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-20T17:32:35.403263 | certora_cli_alpha_master-20260220.17.32.693288.tar.gz | 42,911,449 | 06/a9/d468fd7ac0efb3c1be303d07a037983c2faa7c33857cc40c27a422b66d96/certora_cli_alpha_master-20260220.17.32.693288.tar.gz | source | sdist | null | false | 89e42478f0f10af96a5c840f2ddaa886 | d095189fa00f18fda3feb076bbfc9d4befdfa4d0566b44c19fdc0238b0a605fe | 06a9d468fd7ac0efb3c1be303d07a037983c2faa7c33857cc40c27a422b66d96 | null | [] | 403 |
2.4 | asyncer-slim | 0.0.15 | Asyncer, async and await, focused on developer experience. | <p align="center">
<a href="https://asyncer.tiangolo.com"><img src="https://asyncer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" alt="Asyncer"></a>
</p>
<p align="center">
<em>Asyncer, async and await, focused on developer experience.</em>
</p>
<p align="center">
<a href="https://github.com/fastapi/asyncer/actions?query=workflow%3ATest+event%3Apush+branch%3Amain" target="_blank">
<img src="https://github.com/fastapi/asyncer/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Test">
</a>
<a href="https://github.com/fastapi/asyncer/actions?query=workflow%3APublish" target="_blank">
<img src="https://github.com/fastapi/asyncer/actions/workflows/publish.yml/badge.svg" alt="Publish">
</a>
<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/asyncer" target="_blank">
<img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/asyncer.svg" alt="Coverage">
<a href="https://pypi.org/project/asyncer" target="_blank">
<img src="https://img.shields.io/pypi/v/asyncer?color=%2334D058&label=pypi%20package" alt="Package version">
</a>
</p>
---
**Documentation**: <a href="https://asyncer.tiangolo.com" target="_blank">https://asyncer.tiangolo.com</a>
**Source Code**: <a href="https://github.com/fastapi/asyncer" target="_blank">https://github.com/fastapi/asyncer</a>
---
**Asyncer** is a small library built on top of <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>.
## `asyncer-slim`
⚠️ Do not install this package. ⚠️
This package, `asyncer-slim`, does nothing other than depend on `asyncer`.
You **should not** install this package.
Install instead:
```bash
pip install asyncer
```
This package is deprecated and will stop receiving any updates and published versions.
## License
This project is licensed under the terms of the MIT license.
| text/markdown | null | Sebastián Ramírez <tiangolo@gmail.com> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Framework :: AsyncIO",
"Framework :: Trio",
"Intended Audience :: Developers",
"Intended Audience :: Education",
"Intended Audience :: Information Technology",
"Intended Audience :: Science/Research",
"Intended Audience :: System Administrators",
"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 :: Internet",
"Typing :: Typed"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"asyncer>=0.0.15"
] | [] | [] | [] | [
"Homepage, https://github.com/fastapi/asyncer",
"Documentation, https://asyncer.tiangolo.com",
"Repository, https://github.com/fastapi/asyncer",
"Issues, https://github.com/fastapi/asyncer/issues",
"Changelog, https://asyncer.tiangolo.com/release-notes/"
] | 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-20T17:32:33.731683 | asyncer_slim-0.0.15-py3-none-any.whl | 3,010 | ec/50/6f730e7b7b90eec96d1fe2b8f28b52707a9006c13bef15709dce92dbea22/asyncer_slim-0.0.15-py3-none-any.whl | py3 | bdist_wheel | null | false | 7d1203b3fdc0a2fde195898c3d322d40 | 6880cf55d3222a5379af9511cbdc3b688cfca1f9361a86d7df2cc81ecc7f3d18 | ec506f730e7b7b90eec96d1fe2b8f28b52707a9006c13bef15709dce92dbea22 | MIT | [
"LICENSE"
] | 185 |
2.4 | agentouto | 0.2.0 | Multi-agent Python SDK with peer-to-peer agent communication | # AgentOutO
**멀티 에이전트 특화 Python SDK — 오케스트레이터 없는 피어 간 자유 호출**
A multi-agent Python SDK where every agent is equal. No orchestrator. No hierarchy. No restrictions.
---
## 핵심 철학 (Core Philosophy)
AgentOutO rejects the orchestrator pattern used by existing frameworks (CrewAI, AutoGen, etc.).
> **모든 에이전트는 완전히 대등하다.** Base 에이전트가 존재하지 않는다.
>
> **모든 에이전트는 모든 에이전트를 호출할 수 있다.** 호출 제한이 없다.
>
> **모든 에이전트는 모든 도구를 사용할 수 있다.** 도구 제한이 없다.
>
> **메시지 프로토콜은 전달/반환 2종류뿐이다.**
>
> **사용자는 LLM이 없는 에이전트일 뿐이다.** 별도의 인터페이스, 프로토콜, 도구는 존재하지 않는다.
| Existing Frameworks | AgentOutO |
|---|---|
| Orchestrator-centric hierarchy | Peer-to-peer free calls |
| Base agent required | No base agent |
| Per-agent allowed-call lists | Any agent calls any agent |
| Per-agent tool assignment | All tools are global |
| Complex message protocols | Forward / Return only |
| Top-down message flow | Bidirectional free flow |
---
## Installation
```bash
pip install agentouto
```
Requires Python ≥ 3.11.
---
## Quick Start
```python
from agentouto import Agent, Tool, Provider, run
# Provider — API connection info only
openai = Provider(name="openai", kind="openai", api_key="sk-...")
# Tool — globally available to all agents
@Tool
def search_web(query: str) -> str:
"""Search the web."""
return f"Results for: {query}"
# Agent — model settings live here
researcher = Agent(
name="researcher",
instructions="Research expert. Search and organize information.",
model="gpt-4o",
provider="openai",
)
writer = Agent(
name="writer",
instructions="Skilled writer. Turn research into polished reports.",
model="gpt-4o",
provider="openai",
)
# Run — user is just an agent without an LLM
result = run(
entry=researcher,
message="Write an AI trends report.",
agents=[researcher, writer],
tools=[search_web],
providers=[openai],
)
print(result.output)
```
---
## Architecture
```
┌─────────────────────────────────────────────────────────┐
│ run() │
│ (User = LLM-less agent) │
│ │ │
│ Forward Message │
│ ▼ │
│ ┌─────────────── Agent Loop ──────────────────┐ │
│ │ │ │
│ │ ┌──→ LLM Call (via Provider Backend) │ │
│ │ │ │ │ │
│ │ │ ├── tool_call → Tool.execute() │ │
│ │ │ │ │ │ │
│ │ │ │ result back ───┐ │ │
│ │ │ │ │ │ │
│ │ │ ├── call_agent → New Loop ────┤ │ │
│ │ │ │ │ │ │ │
│ │ │ │ return back ───┐│ │ │
│ │ │ │ ││ │ │
│ │ │ └── finish → Return Message ││ │ │
│ │ │ ││ │ │
│ │ └────────────── next iteration ◄──────┘┘ │ │
│ └─────────────────────────────────────────────┘ │
│ │ │
│ Return Message │
│ ▼ │
│ RunResult.output │
└─────────────────────────────────────────────────────────┘
```
### Message Flow — Peer to Peer
```
[User] ──(forward)──→ [Agent A]
│
├──(forward)──→ [Agent B]
│ ├──(forward)──→ [Agent C]
│ │ │
│ │←──(return)──────┘
│ │
│←──(return)─────┘
│
└──(return)──→ [User]
```
User→A and A→B use the **exact same mechanism**. There is no special user protocol.
### Parallel Calls
```
[Agent A]
├──(forward)──→ [Agent B] ─┐
├──(forward)──→ [Agent C] ├── asyncio.gather — all run concurrently
└──(forward)──→ [Agent D] ─┘
│
←──(3 returns, batched)────┘
```
---
## Core Concepts
### Provider — API Connection Only
Providers hold API credentials. No model settings, no inference config.
```python
from agentouto import Provider
openai = Provider(name="openai", kind="openai", api_key="sk-...")
anthropic = Provider(name="anthropic", kind="anthropic", api_key="sk-ant-...")
google = Provider(name="google", kind="google", api_key="AIza...")
# OpenAI-compatible APIs (vLLM, Ollama, LM Studio, etc.)
local = Provider(name="local", kind="openai", base_url="http://localhost:11434/v1")
```
| Field | Description | Required |
|-------|-------------|----------|
| `name` | Identifier for the provider | ✅ |
| `kind` | API type: `"openai"`, `"anthropic"`, `"google"` | ✅ |
| `api_key` | API key | ✅ |
| `base_url` | Custom endpoint URL (for compatible APIs) | ❌ |
### Agent — Model Settings Live Here
```python
from agentouto import Agent
agent = Agent(
name="researcher",
instructions="Research expert.",
model="gpt-4o",
provider="openai",
max_output_tokens=16384,
reasoning=True,
reasoning_effort="high",
temperature=1.0,
)
```
| Field | Description | Default |
|-------|-------------|---------|
| `name` | Agent name | (required) |
| `instructions` | Role description | (required) |
| `model` | Model name | (required) |
| `provider` | Provider name | (required) |
| `max_output_tokens` | Max output tokens | `4096` |
| `reasoning` | Enable reasoning/thinking mode | `False` |
| `reasoning_effort` | Reasoning intensity | `"medium"` |
| `reasoning_budget` | Thinking token budget (Anthropic) | `None` |
| `temperature` | Temperature | `1.0` |
| `extra` | Additional API parameters (free dict) | `{}` |
The SDK uses unified parameter names. Each provider backend maps them internally:
| SDK Parameter | OpenAI | Anthropic | Google Gemini |
|---|---|---|---|
| `max_output_tokens` | `max_completion_tokens` | `max_tokens` | `max_output_tokens` (in generation_config) |
| `reasoning=True` | sends `reasoning_effort` | `thinking={"type": "enabled", "budget_tokens": ...}` | `thinking_config={"thinking_budget": ...}` |
| `reasoning_effort` | top-level `reasoning_effort` | N/A | N/A |
| `reasoning_budget` | N/A | `thinking.budget_tokens` | `thinking_config.thinking_budget` |
| `temperature` (reasoning=True) | **not sent** | **forced to 1** | sent as-is |
See [`ai-docs/PROVIDER_BACKENDS.md`](./ai-docs/PROVIDER_BACKENDS.md) for full mapping details.
### Tool — Global, No Per-Agent Restrictions
```python
from agentouto import Tool
@Tool
def search_web(query: str) -> str:
"""Search the web."""
return f"Results for: {query}"
# Async tools are supported
@Tool
async def fetch_data(url: str) -> str:
"""Fetch data from URL."""
async with aiohttp.ClientSession() as session:
async with session.get(url) as resp:
return await resp.text()
```
Tools are automatically converted to JSON schemas from function signatures and docstrings. All agents can use all tools.
### Message — Forward and Return Only
```python
@dataclass
class Message:
type: Literal["forward", "return"]
sender: str
receiver: str
content: str
call_id: str # Unique tracking ID
```
Two types. No exceptions.
---
## Supported Providers
| Kind | Provider | Compatible With |
|------|----------|-----------------|
| `"openai"` | OpenAI API | vLLM, Ollama, LM Studio, any OpenAI-compatible API |
| `"anthropic"` | Anthropic API | — |
| `"google"` | Google Gemini API | — |
---
## Async Usage
```python
import asyncio
from agentouto import async_run
result = await async_run(
entry=researcher,
message="Write an AI trends report.",
agents=[researcher, writer, reviewer],
tools=[search_web, write_file],
providers=[openai, anthropic, google],
)
```
---
## Package Structure
```
agentouto/
├── __init__.py # Public API: Agent, Tool, Provider, run, async_run, Message, RunResult
├── agent.py # Agent dataclass
├── tool.py # Tool decorator/class with auto JSON schema generation
├── message.py # Message dataclass (forward/return)
├── provider.py # Provider dataclass (API connection info)
├── context.py # Per-agent conversation context management
├── router.py # Message routing, system prompt generation, tool schema building
├── runtime.py # Agent loop engine, parallel execution, run()/async_run()
├── _constants.py # Shared constants (CALL_AGENT, FINISH)
├── exceptions.py # ProviderError, AgentError, ToolError, RoutingError
└── providers/
├── __init__.py # ProviderBackend ABC, LLMResponse, get_backend()
├── openai.py # OpenAI (+ compatible APIs) implementation
├── anthropic.py # Anthropic implementation
└── google.py # Google Gemini implementation
```
---
## Development Status
| Phase | Description | Status |
|-------|-------------|--------|
| **1** | Core classes: Provider, Agent, Tool, Message | ✅ Done |
| **2** | Single agent execution: agent loop + tool calling | ✅ Done |
| **3** | Multi-agent: call_agent + finish + message routing | ✅ Done |
| **4** | Parallel calls: asyncio.gather concurrent execution | ✅ Done |
| **5** | Streaming, logging, tracing, debug mode | ✅ Done |
| **6** | CI/CD, tests, PyPI publish | 🔶 Partial (CI/CD + tests done, PyPI pending) |
---
## Technical Documentation
For AI contributors and detailed technical reference, see **[`ai-docs/`](./ai-docs/)**:
- [`AI_INSTRUCTIONS.md`](./ai-docs/AI_INSTRUCTIONS.md) — **Read this first.** How to work on this project and update docs.
- [`PHILOSOPHY.md`](./ai-docs/PHILOSOPHY.md) — Core philosophy and inviolable principles.
- [`ARCHITECTURE.md`](./ai-docs/ARCHITECTURE.md) — Package structure, module responsibilities, data flow.
- [`PROVIDER_BACKENDS.md`](./ai-docs/PROVIDER_BACKENDS.md) — Provider system, parameter mapping, API-specific behavior.
- [`MESSAGE_PROTOCOL.md`](./ai-docs/MESSAGE_PROTOCOL.md) — Message types, routing rules, parallel calls, agent loop.
- [`CONVENTIONS.md`](./ai-docs/CONVENTIONS.md) — Coding conventions, patterns, naming, style guide.
- [`ROADMAP.md`](./ai-docs/ROADMAP.md) — Current status, planned features, known issues.
---
## License
Apache License 2.0 — see [LICENSE](./LICENSE) for details.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"anthropic>=0.34.0",
"google-generativeai>=0.8.0",
"openai>=1.50.0",
"mypy>=1.8; extra == \"dev\"",
"pytest-asyncio>=0.23; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:32:05.776156 | agentouto-0.2.0.tar.gz | 40,232 | 00/33/a557fab0bc50ceb70c5a63743bbe3907589685980ab6c8a9dcb602c487aa/agentouto-0.2.0.tar.gz | source | sdist | null | false | 50a66d7c941b7b0e704e2053b4709032 | fe151a2f7a1f8ca8f7c1557abad5c350280c8726a7cfe7889ebf471565fdf6e7 | 0033a557fab0bc50ceb70c5a63743bbe3907589685980ab6c8a9dcb602c487aa | Apache-2.0 | [
"LICENSE"
] | 195 |
2.4 | cyberwave-edge-core | 0.0.16 | The core component of the Cyberwave Edge Node | # Cyberwave Edge Core
This Edge component acts as an orchestrator of your Cyberwave edge components.
## Quickstart (Linux machines)
```bash
# Install the CLI (one time setup)
curl -fsSL "https://packages.buildkite.com/cyberwave/cyberwave-cli/gpgkey" | sudo gpg --dearmor -o /etc/apt/keyrings/cyberwave_cyberwave-cli-archive-keyring.gpg
# Configure the source
echo -e "deb [signed-by=/etc/apt/keyrings/cyberwave_cyberwave-cli-archive-keyring.gpg] https://packages.buildkite.com/cyberwave/cyberwave-cli/any/ any main\ndeb-src [signed-by=/etc/apt/keyrings/cyberwave_cyberwave-cli-archive-keyring.gpg] https://packages.buildkite.com/cyberwave/cyberwave-cli/any/ any main" | sudo tee /etc/apt/sources.list.d/buildkite-cyberwave-cyberwave-cli.list > /dev/null
# Install the CLI
sudo apt update && sudo apt install cyberwave-cli
# Use the CLI to complete the edge setup
sudo cyberwave edge install
```
The cyberwave-cli will ask you to log in with your Cyberwave credentials and then will proceed installing the `cyberwave-edge-core` on your edge device.
> Don't have a Cyberwave account? Get one at [cyberwave.com](https://cyberwave.com)
### Configuration
The edge core reads configuration from `/etc/cyberwave/` (overridable via the `CYBERWAVE_EDGE_CONFIG_DIR` environment variable, which is set in the systemd unit):
| File | Description |
| ------------------ | ------------------------- |
| `credentials.json` | API token, workspace info |
| `fingerprint.json` | Device fingerprint |
| `environment.json` | Linked environment UUID |
Of the files above, the `core` needs only the `credentials.json` file. You can easily populate it with the `cyberwave-cli` as described in the quickstart.
The `fingerprint.json` is populated by the core itself.
## How the edge works
Once it's started (either via CLI or via service) the core does the following:
1. Checks if the credentials stored in `credentials.json` are valid
2. Connects to the backend MQTT and checks if the connection is up and running
3. Registers the `edge` device is running on, or updates its registration record. Each `edge` device is defined by a unique hardware fingerprint
4. Downloads the latest environment from the backend and downloads the list of devices connected to the edge
5. For each `twin`, present in the environment, and connected to the edge: It starts the twin's docker driver image
## Writing compatible drivers
A Cyberwave driver is a Docker image that is capable of interacting with the device's hardware, sending and getting data from the Cyberwave backend. Every time the core starts a driver Docker image, the `core` does so by defining the following environment variables:
- `CYBERWAVE_TWIN_UUID`
- `CYBERWAVE_TOKEN`
- `CYBERWAVE_TWIN_JSON_FILE`
The Cyberwave twin JSON file is an absolute path to a JSON file. The JSON file is writable by the driver. It represents a complete twin object as well as its complete asset object. It represented in the same way that is it in the API, including the whole metadata field, schema and abilities. [Twin reference here](https://docs.cyberwave.com/api-reference/rest/TwinSchema), [Asset reference here](https://docs.cyberwave.com/api-reference/rest/AssetSchema).
As a driver, you can change the JSON file. The core will, when connectivity is present, sync it with the one in the backend.
When writing drivers, use the official Cyberwave SDK to communicate with the backend, as it will abstract a bunch of complexity in the MQTT handshake, REST API authentication, and more.
Once you wrote a driver, you can add its details in the twin's metadata (or the asset's metadata if you own it). Right now the edit is manual and directly in the metadata. To edit the metadata, you can switch to Advanced editing in the environment or in the asset editing.
> Note: If you change the metadata on the asset, every twin created out of that asset from that moment on will have the same metadata as the asset, as the starting point
The driver object in the metadata looks like this:
```json
"drivers": {
"default": {
"docker_image":"cyberwaveos/so101-driver", // this is either a public image on the Docker hub or on your own registry
"version": "0.0.1", // this field is optional
"params" : ["--network local", "--add-host host.docker.internal:host-gateway"] // this is also optional
}
}
```
## Advanced usage
### Manual install and usage
```bash
# Install the registry signing key:
curl -fsSL "https://packages.buildkite.com/cyberwave/cyberwave-edge-core/gpgkey" | gpg --dearmor -o /etc/apt/keyrings/cyberwave_cyberwave-edge-core-archive-keyring.gpg
# Configure the source:
echo -e "deb [signed-by=/etc/apt/keyrings/cyberwave_cyberwave-edge-core-archive-keyring.gpg] https://packages.buildkite.com/cyberwave/cyberwave-edge-core/any/ any main\ndeb-src [signed-by=/etc/apt/keyrings/cyberwave_cyberwave-edge-core-archive-keyring.gpg] https://packages.buildkite.com/cyberwave/cyberwave-edge-core/any/ any main" > /etc/apt/sources.list.d/buildkite-cyberwave-cyberwave-edge-core.list
# Run all startup checks (validate token, MQTT, devices, environment)
cyberwave-edge-core
# Show current credential, token, MQTT, and device status
cyberwave-edge-core status
# Show version
cyberwave-edge-core --version
```
### Other env vars
To run against dev:
```bash
export CYBERWAVE_ENVIRONMENT="dev"
export CYBERWAVE_API_URL="https://api-dev.cyberwave.com"
# Optional SDK alias (kept for compatibility):
export CYBERWAVE_BASE_URL="https://api-dev.cyberwave.com"
cyberwave-edge-core
```
| text/markdown | null | Cyberwave <info@cyberwave.com> | null | null | MIT | null | [
"Development Status :: 3 - Alpha",
"Environment :: Console",
"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 :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"click>=8.1.0",
"cyberwave>=0.3.14",
"httpx>=0.25.0",
"rich>=13.0.0",
"pyinstaller>=6.0.0; extra == \"build\"",
"mypy>=1.5.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest>=7.0.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://cyberwave.com",
"Documentation, https://docs.cyberwave.com",
"Repository, https://github.com/cyberwave-os/cyberwave-edge-core",
"Issues, https://github.com/cyberwave-os/cyberwave-edge-core/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:31:27.338422 | cyberwave_edge_core-0.0.16.tar.gz | 16,887 | f6/fe/761af15ae5e1fb33606596649012e2b7b9920b258cfde95ca401141fed67/cyberwave_edge_core-0.0.16.tar.gz | source | sdist | null | false | d1c10fc84b016ea4f0e9b2b73e8f281c | 78bbfd21b1c88b15adf1108d051da7cf83a431298ceff0e2aa0fc478997bdb25 | f6fe761af15ae5e1fb33606596649012e2b7b9920b258cfde95ca401141fed67 | null | [
"LICENSE"
] | 173 |
2.3 | brew_sdk | 0.4.0 | The official Python library for the brew-sdk API | # Brew SDK Python API library
<!-- prettier-ignore -->
[)](https://pypi.org/project/brew_sdk/)
The Brew SDK Python library provides convenient access to the Brew SDK REST API from any Python 3.9+
application. The library includes type definitions for all request params and response fields,
and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).
It is generated with [Stainless](https://www.stainless.com/).
## Documentation
The REST API documentation can be found on [brew.new](https://brew.new). The full API of this library can be found in [api.md](https://github.com/GetBrew/brew-python-sdk/tree/main/api.md).
## Installation
```sh
# install from PyPI
pip install brew_sdk
```
## Usage
The full API of this library can be found in [api.md](https://github.com/GetBrew/brew-python-sdk/tree/main/api.md).
```python
from brew_sdk import BrewSDK
client = BrewSDK()
import_ = client.contacts.import_.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
)
print(import_.data)
```
While you can provide an `api_key` keyword argument,
we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
to add `BREW_SDK_API_KEY="My API Key"` to your `.env` file
so that your API Key is not stored in source control.
## Async usage
Simply import `AsyncBrewSDK` instead of `BrewSDK` and use `await` with each API call:
```python
import asyncio
from brew_sdk import AsyncBrewSDK
client = AsyncBrewSDK()
async def main() -> None:
import_ = await client.contacts.import_.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
)
print(import_.data)
asyncio.run(main())
```
Functionality between the synchronous and asynchronous clients is otherwise identical.
### With aiohttp
By default, the async client uses `httpx` for HTTP requests. However, for improved concurrency performance you may also use `aiohttp` as the HTTP backend.
You can enable this by installing `aiohttp`:
```sh
# install from PyPI
pip install brew_sdk[aiohttp]
```
Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
```python
import asyncio
from brew_sdk import DefaultAioHttpClient
from brew_sdk import AsyncBrewSDK
async def main() -> None:
async with AsyncBrewSDK(
http_client=DefaultAioHttpClient(),
) as client:
import_ = await client.contacts.import_.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
)
print(import_.data)
asyncio.run(main())
```
## Using types
Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:
- Serializing back into JSON, `model.to_json()`
- Converting to a dictionary, `model.to_dict()`
Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.
## Handling errors
When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `brew_sdk.APIConnectionError` is raised.
When the API returns a non-success status code (that is, 4xx or 5xx
response), a subclass of `brew_sdk.APIStatusError` is raised, containing `status_code` and `response` properties.
All errors inherit from `brew_sdk.APIError`.
```python
import brew_sdk
from brew_sdk import BrewSDK
client = BrewSDK()
try:
client.contacts.import_.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
)
except brew_sdk.APIConnectionError as e:
print("The server could not be reached")
print(e.__cause__) # an underlying Exception, likely raised within httpx.
except brew_sdk.RateLimitError as e:
print("A 429 status code was received; we should back off a bit.")
except brew_sdk.APIStatusError as e:
print("Another non-200-range status code was received")
print(e.status_code)
print(e.response)
```
Error codes are as follows:
| Status Code | Error Type |
| ----------- | -------------------------- |
| 400 | `BadRequestError` |
| 401 | `AuthenticationError` |
| 403 | `PermissionDeniedError` |
| 404 | `NotFoundError` |
| 422 | `UnprocessableEntityError` |
| 429 | `RateLimitError` |
| >=500 | `InternalServerError` |
| N/A | `APIConnectionError` |
### Retries
Certain errors are automatically retried 2 times by default, with a short exponential backoff.
Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
429 Rate Limit, and >=500 Internal errors are all retried by default.
You can use the `max_retries` option to configure or disable retry settings:
```python
from brew_sdk import BrewSDK
# Configure the default for all requests:
client = BrewSDK(
# default is 2
max_retries=0,
)
# Or, configure per-request:
client.with_options(max_retries=5).contacts.import_.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
)
```
### Timeouts
By default requests time out after 1 minute. You can configure this with a `timeout` option,
which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:
```python
from brew_sdk import BrewSDK
# Configure the default for all requests:
client = BrewSDK(
# 20 seconds (default is 1 minute)
timeout=20.0,
)
# More granular control:
client = BrewSDK(
timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)
# Override per-request:
client.with_options(timeout=5.0).contacts.import_.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
)
```
On timeout, an `APITimeoutError` is thrown.
Note that requests that time out are [retried twice by default](https://github.com/GetBrew/brew-python-sdk/tree/main/#retries).
## Advanced
### Logging
We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.
You can enable logging by setting the environment variable `BREW_SDK_LOG` to `info`.
```shell
$ export BREW_SDK_LOG=info
```
Or to `debug` for more verbose logging.
### How to tell whether `None` means `null` or missing
In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:
```py
if response.my_field is None:
if 'my_field' not in response.model_fields_set:
print('Got json like {}, without a "my_field" key present at all.')
else:
print('Got json like {"my_field": null}.')
```
### Accessing raw response data (e.g. headers)
The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,
```py
from brew_sdk import BrewSDK
client = BrewSDK()
response = client.contacts.import_.with_raw_response.create(
contacts=[{
"email": "john@example.com"
}, {
"email": "jane@example.com"
}],
)
print(response.headers.get('X-My-Header'))
import_ = response.parse() # get the object that `contacts.import_.create()` would have returned
print(import_.data)
```
These methods return an [`APIResponse`](https://github.com/GetBrew/brew-python-sdk/tree/main/src/brew_sdk/_response.py) object.
The async client returns an [`AsyncAPIResponse`](https://github.com/GetBrew/brew-python-sdk/tree/main/src/brew_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
#### `.with_streaming_response`
The above interface eagerly reads the full response body when you make the request, which may not always be what you want.
To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
```python
with client.contacts.import_.with_streaming_response.create(
contacts=[{"email": "john@example.com"}, {"email": "jane@example.com"}],
) as response:
print(response.headers.get("X-My-Header"))
for line in response.iter_lines():
print(line)
```
The context manager is required so that the response will reliably be closed.
### Making custom/undocumented requests
This library is typed for convenient access to the documented API.
If you need to access undocumented endpoints, params, or response properties, the library can still be used.
#### Undocumented endpoints
To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
http verbs. Options on the client will be respected (such as retries) when making this request.
```py
import httpx
response = client.post(
"/foo",
cast_to=httpx.Response,
body={"my_param": True},
)
print(response.headers.get("x-foo"))
```
#### Undocumented request params
If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
options.
#### Undocumented response properties
To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
can also get all the extra fields on the Pydantic model as a dict with
[`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).
### Configuring the HTTP client
You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:
- Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
- Custom [transports](https://www.python-httpx.org/advanced/transports/)
- Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality
```python
import httpx
from brew_sdk import BrewSDK, DefaultHttpxClient
client = BrewSDK(
# Or use the `BREW_SDK_BASE_URL` env var
base_url="http://my.test.server.example.com:8083",
http_client=DefaultHttpxClient(
proxy="http://my.test.proxy.example.com",
transport=httpx.HTTPTransport(local_address="0.0.0.0"),
),
)
```
You can also customize the client on a per-request basis by using `with_options()`:
```python
client.with_options(http_client=DefaultHttpxClient(...))
```
### Managing HTTP resources
By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.
```py
from brew_sdk import BrewSDK
with BrewSDK() as client:
# make requests here
...
# HTTP client is now closed
```
## Versioning
This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
1. Changes that only affect static types, without breaking runtime behavior.
2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
3. Changes that we do not expect to impact the vast majority of users in practice.
We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
We are keen for your feedback; please open an [issue](https://www.github.com/GetBrew/brew-python-sdk/issues) with questions, bugs, or suggestions.
### Determining the installed version
If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.
You can determine the version that is being used at runtime with:
```py
import brew_sdk
print(brew_sdk.__version__)
```
## Requirements
Python 3.9 or higher.
## Contributing
See [the contributing documentation](https://github.com/GetBrew/brew-python-sdk/tree/main/./CONTRIBUTING.md).
| text/markdown | null | Brew SDK <support@brew.new> | null | null | Apache-2.0 | null | [
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows",
"Operating System :: OS Independent",
"Operating System :: POSIX",
"Operating System :: POSIX :: Linux",
"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 :: Software Development :: Libraries :: Python Modules",
"Typing :: Typed"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"anyio<5,>=3.5.0",
"distro<2,>=1.7.0",
"httpx<1,>=0.23.0",
"pydantic<3,>=1.9.0",
"sniffio",
"typing-extensions<5,>=4.10",
"aiohttp; extra == \"aiohttp\"",
"httpx-aiohttp>=0.1.9; extra == \"aiohttp\""
] | [] | [] | [] | [
"Homepage, https://github.com/GetBrew/brew-python-sdk",
"Repository, https://github.com/GetBrew/brew-python-sdk"
] | uv/0.9.13 {"installer":{"name":"uv","version":"0.9.13"},"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-20T17:30:53.809535 | brew_sdk-0.4.0.tar.gz | 226,047 | b5/b7/13b1b8c9be87fa63c0dc285c8ce4c2e95209161af6edd647978263d8a571/brew_sdk-0.4.0.tar.gz | source | sdist | null | false | 6a7ba6a6e26d7c9bc378db6f669d7362 | 712e02e81bf5b0abfe091709441575632c6354a52db9c5d7c8913a70e9566fb7 | b5b713b1b8c9be87fa63c0dc285c8ce4c2e95209161af6edd647978263d8a571 | null | [] | 0 |
2.4 | jacobs-jinja-too | 0.2.14 | Simple wrapper around jinja2 templating | # Jacob's Jinja Too
[](https://circleci.com/gh/pearmaster/jacobs-jinja-too/tree/master)
A simple wrapper around Jinja2 templating with a collection of custom filters. [Jinja2](https://jinja.palletsprojects.com/en/2.11.x/) is a templating language for Python.
Only tested with Python3.7.
The main purpose for this project is for depencency management as this diagram shows:
```plantuml
[Top Level Project] --> [jacobs-jinja-too] : uses
[Top Level Project] --> [Another Project] : depends
[Another Project] --> [jacobs-jinja-too] : uses
```
## Installation
```sh
pip3 install jacobs-jinja-too
```
## Example Usage
```python
from jacobsjinjatoo import Templator as jj2
t = jj2.MarkdownTemplator()
t.add_template_dir('templates/')
params = {
"name": "My Name"
}
t.render_template('foo.jinja2', output_name='foo.txt', **params)
```
## License
GPLv2
There is no copyright claim or ownership of any content created by jacobs-jinja-too.
| text/markdown | null | Jacob Brunson <pypi@jacobbrunson.com> | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"jinja-markdown>=1.210911",
"jinja2>=3.1.6"
] | [] | [] | [] | [
"Homepage, http://github.com/pearmaster/jacobs-jinja-too"
] | uv/0.9.12 {"installer":{"name":"uv","version":"0.9.12"},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"25.10","id":"questing","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null} | 2026-02-20T17:30:36.982138 | jacobs_jinja_too-0.2.14-py3-none-any.whl | 13,981 | d0/c9/057e1c38a62339636fb6aa07bf185b721a43dd741e2e884632c9157e66a0/jacobs_jinja_too-0.2.14-py3-none-any.whl | py3 | bdist_wheel | null | false | 6897918f4d0ae620967d0c124ee62aa5 | f9eb4f56734cc1cff3283d47062b7f68cac510e42da4ce74d38aac797b194ead | d0c9057e1c38a62339636fb6aa07bf185b721a43dd741e2e884632c9157e66a0 | LGPL-2.0 | [
"LICENSE"
] | 202 |
2.4 | wati-mcp | 0.2.0 | WhatsApp MCP Server using Wati API v3 | # WhatsApp MCP Server with Wati API v3
This is a Model Context Protocol (MCP) server for WhatsApp using the Wati API **v3**.
Manage your WhatsApp conversations, contacts, templates, campaigns, and channels through AI assistants like Claude. Search and read messages, send texts and files, manage contacts, and automate workflows — all via MCP tools.
> To get updates on this and other projects [enter your email here](https://docs.google.com/forms/d/1rTF9wMBTN0vPfzWuQa2BjfGKdKIpTbyeKxhPMcEzgyI/preview)
## What's New in v0.2.0
**Breaking change:** This release migrates from the legacy Wati v1 API to the **v3 API** (`/api/ext/v3/*`).
### Changes
- **API v3 migration** — All endpoints updated to `/api/ext/v3/*` paths
- **URL scheme** — Tenant ID no longer embedded in URL path; resolved from Bearer token
- **`WATI_TENANT_ID` is now optional** — Only needed for multi-channel setups (Channel:PhoneNumber targeting)
- **New tools:** `list_contacts`, `get_contact`, `add_contact`, `update_contacts`, `get_contact_count`, `assign_contact_teams`, `send_file_via_url`, `send_interactive` (buttons + list), `assign_operator`, `update_conversation_status`, `list_templates`, `get_template`, `send_template`, `list_campaigns`, `get_campaign`, `list_channels`
- **Removed tools:** `list_chats`, `get_chat`, `get_direct_chat_by_contact`, `get_contact_chats` (replaced by `list_contacts`/`get_contact`/`get_messages`)
- **Simplified response parsing** — v3 has standardized response schemas
### Migration Guide
1. Update `WATI_API_BASE_URL` to your Wati server (e.g. `https://live-mt-server.wati.io`)
2. `WATI_TENANT_ID` can be removed unless you use multi-channel targeting
3. Update tool calls: `send_message(recipient=...)` → `send_message(target=...)`
4. Replace `list_chats`/`get_chat` with `list_contacts`/`get_contact` + `get_messages`
## Installation
### Installing via Smithery
```bash
npx -y @smithery/cli install @wati-io/wati-mcp-server --client claude
```
[](https://smithery.ai/server/@wati-io/wati-mcp-server)
### Prerequisites
- Python 3.11+
- Anthropic Claude Desktop app (or Cursor)
- UV (Python package manager), install with `curl -LsSf https://astral.sh/uv/install.sh | sh`
- Wati API access (you'll need your authentication token)
### Steps
1. **Clone this repository**
```bash
git clone https://github.com/wati-io/wati-mcp-server.git
cd wati-mcp-server
```
2. **Configure the Wati API**
Copy the example environment file and edit it with your Wati API credentials:
```bash
cp .env.example .env
# Edit .env with your Wati API credentials
```
Required:
- `WATI_API_BASE_URL`: The base URL for the Wati API (e.g. `https://live-mt-server.wati.io`)
- `WATI_AUTH_TOKEN`: Your Wati authentication token (Bearer token from dashboard)
Optional:
- `WATI_TENANT_ID`: Your Wati tenant ID (only for multi-channel setups)
3. **Connect to the MCP server**
Copy the below json with the appropriate {{PATH}} values:
```json
{
"mcpServers": {
"whatsapp": {
"command": "{{PATH_TO_UV}}",
"args": [
"--directory",
"{{PATH_TO_SRC}}/wati-mcp-server",
"run",
"main.py"
]
}
}
}
```
For **Claude**, save this as `claude_desktop_config.json` in:
```
~/Library/Application Support/Claude/claude_desktop_config.json
```
For **Cursor**, save this as `mcp.json` in:
```
~/.cursor/mcp.json
```
4. **Restart Claude Desktop / Cursor**
## MCP Tools
### Contacts
- **search_contacts** — Search contacts by name or phone number
- **list_contacts** — List contacts with pagination
- **get_contact** — Get detailed contact info by phone or ID
- **add_contact** — Add a new WhatsApp contact
- **update_contacts** — Bulk-update contact custom parameters
- **get_contact_count** — Get total contact count
- **assign_contact_teams** — Assign a contact to teams
### Messages & Conversations
- **get_messages** — Get conversation messages for a contact
- **send_message** — Send a text message
- **send_file** — Send a file (image, video, document, audio) via upload
- **send_file_via_url** — Send a file by URL (no local download needed)
- **download_media** — Download media from a message
- **send_interactive** — Send interactive buttons or list messages
- **assign_operator** — Assign an operator to a conversation
- **update_conversation_status** — Update conversation status (open/solved/pending/block)
### Templates
- **list_templates** — List message templates
- **get_template** — Get template details
- **send_template** — Send template messages to recipients
### Campaigns
- **list_campaigns** — List broadcast campaigns
- **get_campaign** — Get campaign details and statistics
### Channels
- **list_channels** — List available WhatsApp channels
## Architecture
```
Claude/AI Assistant
↕ MCP Protocol (stdio)
Python MCP Server (FastMCP)
↕ HTTPS + Bearer Auth
Wati API v3
↕
WhatsApp Business
```
1. Claude sends requests to the Python MCP server via MCP protocol
2. The MCP server makes authenticated API calls to the Wati v3 API
3. The Wati API communicates with WhatsApp's backend
4. Data flows back through the chain to Claude
## Troubleshooting
- **Authentication errors**: Ensure your `WATI_AUTH_TOKEN` is valid and not expired
- **404 errors**: Make sure `WATI_API_BASE_URL` points to your correct Wati server
- **Rate limiting**: The Wati API has rate limits. If you hit them, wait or contact Wati support
- **Media upload failures**: Check file type support and size limits
- **Permission issues with uv**: Add it to your PATH or use the full path to the executable
For MCP integration troubleshooting, see the [MCP documentation](https://modelcontextprotocol.io/quickstart/server#claude-for-desktop-integration-issues).
| text/markdown | WhatsApp MCP Contributors | null | null | null | MIT License
Copyright (c) 2025 Luke Harries
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.11 | [] | [] | [] | [
"requests>=2.28.0",
"python-dotenv>=0.21.0",
"mcp>=1.6.0",
"mcp[cli]>=1.6.0; extra == \"cli\"",
"pytest>=7.0.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.5 | 2026-02-20T17:30:34.985970 | wati_mcp-0.2.0.tar.gz | 16,937 | 65/65/8621bc311018acf5d3259a98514e105c479c8da10b69ac27f88e406ab907/wati_mcp-0.2.0.tar.gz | source | sdist | null | false | 99b0ef156a88da0a74d9b1b46edfdfd6 | 863c72f3c37bcf54897a74b0f07ed837af559d83a02a6a7f966feb3010f66dfc | 65658621bc311018acf5d3259a98514e105c479c8da10b69ac27f88e406ab907 | null | [
"LICENSE"
] | 201 |
2.4 | sqlsaber-viz | 0.4.0 | SQLsaber terminal visualization plugin | # SQLSaber Visualization Plugin
Provides the `viz` tool for SQLSaber via the `sqlsaber-viz` plugin. The tool generates a declarative chart spec and renders ASCII charts in the terminal using plotext.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"plotext>=5.3.0",
"sqlsaber>=0.55.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-20T17:30:32.797456 | sqlsaber_viz-0.4.0-py3-none-any.whl | 17,145 | 93/16/6c9e8877ac1652753e620f9c38d3ae28284550e14236a0ce728faab064d0/sqlsaber_viz-0.4.0-py3-none-any.whl | py3 | bdist_wheel | null | false | c3592834cb24c9cdf15ff1e5a84ce4bf | 39ef25960d964b26cee4eab0f374a424cf282e555ed841df6c85c9d4175d1498 | 93166c9e8877ac1652753e620f9c38d3ae28284550e14236a0ce728faab064d0 | null | [] | 187 |
2.4 | gwseq-io | 0.0.19 | Process BBI (bigWig/bigBed) and HiC files | ## Installation
```
pip install gwseq-io
```
Requires numpy and pybind11.
## Usage
### Open bigWig, bigBed and HiC files
```python
reader = gwseq_io.open(path, *, parallel, zoom_correction, file_buffer_size, max_file_buffer_count)
```
Parameters:
- `parallel` Number of parallel file handles and processing threads. 24 by default.
- `zoom_correction` Scaling factor for automatic zoom level selection based on bin size. Only for bigWig files. 1/3 by default.
- `file_buffer_size` Size in bytes of each file buffer for caching file reads. Use -1 for recommended (32768 or 1048576 for URLs). -1 by default.
- `max_file_buffer_count` Maximum number of file buffers to keep in cache. Use -1 for recommended (128). -1 by default.
Attributes for bigWig and bigBed files:
- `main_header` General file formatting info.
- `zoom_headers` Zooms levels info (reduction level and location).
- `auto_sql` BED entries declaration (only in bigBed).
- `total_summary` Statistical summary of entire file values (coverage, sums and extremes).
- `chr_sizes` Chromosomes IDs and sizes.
- `type` Either "bigwig" or "bigbed".
Attributes for HiC files:
- `header` `footer` General file info.
- `chr_sizes` Chromosomes IDs and sizes.
- `normalizations` Available normalizations.
- `units` Available units.
- `bin_sizes` Available bin sizes.
### Read bigWig and bigBed signal
```python
values = reader.read_signal(chr_ids, starts, ends)
values = reader.read_signal(chr_ids, starts=starts, span=span)
values = reader.read_signal(chr_ids, ends=ends, span=span)
values = reader.read_signal(chr_ids, centers=centers, span=span)
```
Parameters:
- `chr_ids` `starts` `ends` `centers` Chromosomes ids, starts, ends and centers of locations. Both `starts` `ends` or one of `starts` `ends` `centers` (with `span`) may be specified.
- `span` Reading window in bp relative to locations `starts` `ends` `centers`. Only one reference may be specified if specified. Not by default.
- `bin_size` Reading bin size in bp. May vary in output if locations have variable spans or `bin_count` is specified. 1 by default.
- `bin_count` Output bin count. Inferred as max location span / bin size by default.
- `bin_mode` Method to aggregate bin values. Either "mean", "sum" or "count". "mean" by default.
- `full_bin` Extend locations ends to overlapping bins if true. Not by default.
- `def_value` Default value to use when no data overlap a bin. 0 by default.
- `zoom` BigWig zoom level to use. Use full data if -1. Auto-detect the best level if -2 by selecting the larger level whose bin size is lower than the third of `bin_size` (may be the full data). Full data by default.
- `progress` Function called during data extraction. Takes the extracted coverage and the total coverage in bp as parameters. Use default callback function if true. None by default.
Returns a numpy float32 array of shape (locations, bin count).
### Quantify bigWig and bigBed signal
```python
values = reader.quantify(chr_ids, starts, ends)
```
Parameters:
- `chr_ids` `starts` `ends` `centers` `span` `bin_size` `full_bin` `def_value` `zoom` `progress` Identical to `read_signal` method.
- `reduce` Method to aggregate values over span. Either "mean", "sd", "sem", "sum", "count", "min", "max", "l1norm" or "l2norm". "mean" by default.
Returns a numpy float32 array of shape (locations).
### Profile bigWig and bigBed signal
```python
values = reader.profile(chr_ids, starts, ends)
```
Parameters:
- `chr_ids` `starts` `ends` `centers` `span` `bin_size` `bin_count` `bin_mode` `full_bin` `def_value` `zoom` `progress` Identical to `read_signal` method.
- `reduce` Method to aggregate values over locations. Either "mean", "sd", "sem", "sum", "count", "min", "max", "l1norm" or "l2norm". "mean" by default.
Returns a numpy float32 array of shape (bin count).
### Read bigBed entries
```python
values = reader.read_entries(chr_ids, starts, ends)
```
Parameters:
- `chr_ids` `starts` `ends` `centers` `spans` `progress` Identical to `read_signal` method.
Returns a list (locations) of list of entries (dict with at least "chr", "start" and "end" keys).
### Read all bigBed entries
```python
values = reader.read_all_entries()
```
Parameters:
- `chr_ids` Only extract data from these chromosomes. All by default.
Returns a list of entries (dict with at least "chr", "start" and "end" keys).
### Convert bigWig to bedGraph or WIG
```python
reader.to_bedgraph(output_path)
reader.to_wig(output_path)
```
Parameters:
- `output_path` Path to output file.
- `chr_ids` Only extract data from these chromosomes. All by default.
- `zoom` Zoom level to use. Use full data if -1. Full data by default.
- `progress` Function called during data extraction. Takes the extracted coverage and the total coverage in bp as parameters. None by default.
### Convert bigBed to BED
```python
reader.to_bed(output_path)
```
Parameters:
- `output_path` `chr_ids` `progress` Identical to `to_bedgraph` and `to_wig` methods.
- `col_count` Only write this number of columns (eg, 3 for chr, start and end). All by default.
### Write bigWig file
```python
writer = bigwig_io.open(path, "w")
writer = bigwig_io.open(path, "w", def_value=0)
writer = bigwig_io.open(path, "w", chr_sizes={"chr1": 1234, "chr2": 1234})
writer.add_entry("chr1", start=1000, end=1010, value=0.1)
writer.add_value("chr1", start=1000, span=10, value=0.1)
writer.add_values("chr1", start=1000, span=10, values=[0.1, 0.1, 0.1, 0.1])
```
must be pooled by chr, and sorted by (1) start (2) end
no overlap
### Write bigBed file
```python
writer = bigwig_io.open(path, "w", type="bigbed")
writer = bigwig_io.open(path, "w", type="bigbed", chr_sizes={"chr1": 1234, "chr2": 1234})
writer = bigwig_io.open(path, "w", type="bigbed", fields=["chr", "start", "end", "name"])
writer = bigwig_io.open(path, "w", type="bigbed", fields={"chr": "string", "start", "uint", "end": "uint", "name": "string"})
writer.add_entry("chr1", start=1000, end=1010)
writer.add_entry("chr1", start=1000, end=1010, fields={"name": "read#1"})
```
must be pooled by chr, and sorted by (1) start (2) end
may be overlapping
### Read HiC signal
```python
values = reader.read_signal(chr_ids, starts, ends)
```
Parameters:
- `chr_ids` `starts` `ends` Chromosomes ids, starts and ends of the 2 locations.
- `bin_size` Input bin size or -1 to use the smallest. Must be available in the file. Smallest by default.
- `bin_count` Approximate output bin count. Takes precedence over `bin_size` if specified by selecting the closest bin size resulting in `bin_count`. Not specified by default.
- `exact_bin_count` Resize output to match `bin_count` (if specified). Not by default.
- `full_bin` Extend locations ends to overlapping bins if true. Not by default.
- `def_value` Default value to use when no data overlap a bin. 0 by default.
- `triangle` Skip symmetrical data if true. Not by default.
- `min_distance` `max_distance` Min and max distance in bp from diagonal for contacts to be reported. All by default.
- `normalization` Either "none" or any normalization available in the file, such as "kr", "vc" or "vc_sqrt". "none" by default.
- `mode` Either "observed" or "oe" (observed/expected). "observed" by default.
- `unit` Either "bp" or "frag". "bp" by default.
- `save_to` Save output to this .npz path (under "values" key) and return nothing. Not by default.
Returns a numpy float32 array of shape (loc 1 bins, loc 2 bins).
### Read HiC sparse signal
```python
values = reader.read_sparse_signal(chr_ids, starts, ends)
```
Parameters:
- `chr_ids` `starts` `ends` `bin_size` `bin_count` `exact_bin_count` `full_bin` `def_value` `triangle` `min_distance` `max_distance` `normalization` `mode` `unit` `save_to` Identical to `read_signal` method.
Returns a COO sparse matrix as a dict with keys:
- `values` Values as a numpy float32 array.
- `row` Values rows indices as a numpy uint32 array.
- `col` Values columns indices as a numpy uint32 array.
- `shape` Shape of the dense array as a tuple.
Convert in python using `scipy.sparse.csr_array((x["values"], (x["row"], x["col"])), shape=x["shape"])`.
| text/markdown | null | Arthur Gouhier <ajgouhier@gmail.com> | null | null | null | null | [] | [] | null | null | >=3.8 | [] | [] | [] | [
"numpy",
"pybind11>=2.6.0"
] | [] | [] | [] | [
"Repository, https://github.com/ajgouhier/gwseq_io"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-20T17:30:10.871758 | gwseq_io-0.0.19.tar.gz | 71,160 | b0/e5/8fd41205ba3ac3c3875c02a1c09cd5d3b84fbfbaa10a9dc4433bb0b908c0/gwseq_io-0.0.19.tar.gz | source | sdist | null | false | 7478c1bd49ff411be26a05bfcabb6ceb | 74c9f6afae46b6ee69839cf3d69f05d971a10db7dc7ac2de4e441265f22e6517 | b0e58fd41205ba3ac3c3875c02a1c09cd5d3b84fbfbaa10a9dc4433bb0b908c0 | MIT | [
"LICENSE"
] | 171 |
2.4 | speechmarkdown | 1.0.2 | Speech Markdown library for Python. | # SpeechMarkdown
[](https://pypi.org/project/speechmarkdown/)
[](https://speechmarkdown-py.github.io/speechmarkdown-py/)
Speech Markdown library for Python.
This is a Python port of the original [speechmarkdown-js](https://github.com/speechmarkdown/speechmarkdown-js).
## Installation
```bash
$ pip install speechmarkdown
```
## Usage
For usage, please consult the [docs](docs/index.md).
## Development Setup
We use [`mise`](https://mise.jdx.dev/) for managing the development environment and tooling, and `poetry` for python package dependency management.
1. Install `mise`, if you haven't already.
2. In the project root, run `mise install` to install python and poetry.
3. Run `poetry install`
4. Run tests with `make test` or full CI suite with `make lint-type-test`.
| text/markdown | Takeshi Teshima | takeshi.78.teshima@gmail.com | null | null | Apache-2.0 | null | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | null | null | <4.0,>=3.11 | [] | [] | [] | [
"pyparsing<4.0.0,>=3.3.2"
] | [] | [] | [] | [
"Homepage, https://github.com/takeshi-teshima/speechmarkdown",
"Repository, https://github.com/takeshi-teshima/speechmarkdown"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:29:51.289217 | speechmarkdown-1.0.2.tar.gz | 67,178 | da/70/7a74b973b3583fb63d1ff0dcf46cc1424d86c15bcd9cf31727a4d0650e11/speechmarkdown-1.0.2.tar.gz | source | sdist | null | false | 4b29a0142608e5102057e8a5ef7a36b0 | 06d1177475f04ef3b20ce0664313ac2f0ccc588df3109a18136228e0dfd3d811 | da707a74b973b3583fb63d1ff0dcf46cc1424d86c15bcd9cf31727a4d0650e11 | null | [
"LICENSE"
] | 183 |
2.4 | agentwire-dev | 1.7.0 | Multi-session voice web interface for AI coding agents | <p align="center">
<img src="https://agentwire.dev/images/splash-full-transparent.png" alt="AgentWire" width="500">
</p>
<p align="center">
<strong>Talk to your AI coding agents. From anywhere.</strong>
</p>
<p align="center">
<a href="https://pypi.org/project/agentwire-dev/"><img src="https://img.shields.io/pypi/v/agentwire-dev?color=green" alt="PyPI"></a>
<a href="https://pypi.org/project/agentwire-dev/"><img src="https://img.shields.io/pypi/pyversions/agentwire-dev" alt="Python"></a>
<a href="https://github.com/dotdevdotdev/agentwire-dev/blob/main/LICENSE"><img src="https://img.shields.io/github/license/dotdevdotdev/agentwire-dev" alt="License"></a>
<a href="https://discord.gg/bspFZNTdUr"><img src="https://img.shields.io/discord/1234567890?color=5865F2&label=discord" alt="Discord"></a>
</p>
---
## The Problem
You're on the couch. Your AI agent is on your workstation. You have an idea.
Old way: Get up. Walk to computer. Type.
**AgentWire way:** Pull out phone. Hold button. Talk. Done.
---
## What It Does
Push-to-talk voice control for [Claude Code](https://github.com/anthropics/claude-code) or any AI coding assistant running in tmux.
<p align="center">
<img src="https://agentwire.dev/images/demo.gif" alt="Demo" width="600">
</p>
```
Phone → AgentWire Portal → tmux session → Claude Code
🎤 (WebSocket) 📺 🤖
```
**From your phone, tablet, or laptop on your network:**
- Hold to speak, release to send
- Watch agents work in real-time
- Hear responses via TTS
- Manage multiple projects simultaneously
---
## Quick Start
```bash
# Install
pip install agentwire-dev
# Setup (interactive)
agentwire init
agentwire generate-certs
# Run
agentwire portal start
# Open https://localhost:8765
```
**Requirements:** Python 3.10+, tmux, ffmpeg, Claude Code
<details>
<summary><strong>Platform-specific instructions</strong></summary>
**macOS:**
```bash
brew install tmux ffmpeg
pip install agentwire-dev
```
**Ubuntu/Debian:**
```bash
sudo apt install tmux ffmpeg python3-pip python3-venv
python3 -m venv ~/.agentwire-venv && source ~/.agentwire-venv/bin/activate
pip install agentwire-dev
```
**WSL2:** Same as Ubuntu. Audio is limited; use as remote worker with portal on Windows host.
</details>
---
## Features
| Feature | Description |
|---------|-------------|
| **Voice Control** | Push-to-talk from any device on your network |
| **Multi-Session** | Run multiple agents on different projects simultaneously |
| **Git Worktrees** | Same project, multiple branches, parallel agents |
| **Remote Machines** | SSH into GPU servers and talk to agents there |
| **Worker Orchestration** | Spawn worker panes, coordinate tasks, voice commands |
| **Safety Hooks** | 300+ dangerous commands blocked (rm -rf, force push, etc.) |
| **TTS Responses** | Agents talk back via browser audio |
| **Session Roles** | Leader/worker patterns for multi-agent workflows |
---
## How It Works
**1. Create a session:**
```bash
agentwire new -s myproject -p ~/projects/myproject
```
**2. Open the portal:**
Visit `https://localhost:8765` on your phone/tablet/laptop
**3. Talk:**
Hold the mic button, speak your request, release. The transcription goes to Claude Code.
**4. Listen:**
Agent responses are spoken back via TTS (optional, requires GPU for self-hosted or RunPod).
---
## Multi-Agent Orchestration
AgentWire supports orchestrator/worker patterns for complex tasks:
```yaml
# .agentwire.yml in your project
type: claude-bypass
roles:
- agentwire
- voice
```
**Sessions** can spawn workers:
```bash
agentwire spawn --roles worker # Creates a worker pane
agentwire send --pane 1 "Implement the auth module"
```
Workers execute tasks autonomously while the orchestrator coordinates.
---
## Safety
AgentWire blocks dangerous operations before they execute:
- `rm -rf /`, `git push --force`, `git reset --hard`
- Cloud CLI destructive ops (AWS, GCP, Firebase, Vercel)
- Database drops, Redis flushes, container nukes
- Sensitive file access (.env, SSH keys, credentials)
```bash
agentwire safety check "rm -rf /"
# → ✗ BLOCKED: rm with recursive or force flags
agentwire safety status
# → 312 patterns loaded, 47 blocks today
```
All decisions logged for audit trails.
---
## Voice Configuration
**TTS (Text-to-Speech):** Requires GPU. Options:
```yaml
# ~/.agentwire/config.yaml
tts:
backend: "runpod" # Recommended: RunPod serverless
runpod_endpoint_id: "your-endpoint"
runpod_api_key: "your-key"
```
Or self-host with `agentwire tts start` on a GPU machine.
**STT (Speech-to-Text):** Runs locally on macOS via WhisperKit. Linux uses faster-whisper server.
<details>
<summary><strong>Disable voice (text-only mode)</strong></summary>
```yaml
tts:
backend: "none"
```
You can still use the portal for session management without voice.
</details>
---
## CLI Reference
<details>
<summary><strong>Session Management</strong></summary>
```bash
agentwire list # List sessions
agentwire new -s <name> -p <path> # Create session
agentwire kill -s <name> # Kill session
agentwire send -s <name> "prompt" # Send to session
agentwire output -s <name> # Read output
```
</details>
<details>
<summary><strong>Worker Panes</strong></summary>
```bash
agentwire spawn --roles worker # Spawn worker in current session
agentwire send --pane 1 "task" # Send to worker
agentwire output --pane 1 # Read worker output
agentwire kill --pane 1 # Kill worker
```
</details>
<details>
<summary><strong>Voice Commands</strong></summary>
```bash
agentwire say "Hello" # TTS (auto-routes to browser)
agentwire alert "Done" # Text notification (no audio)
agentwire listen start/stop # Voice recording
agentwire voiceclone list # Custom voices
```
</details>
<details>
<summary><strong>Remote Machines</strong></summary>
```bash
agentwire machine add gpu --host 10.0.0.5 --user dev
agentwire new -s ml@gpu # Create session on remote
agentwire tunnels up # SSH tunnels for services
```
</details>
<details>
<summary><strong>Safety & Diagnostics</strong></summary>
```bash
agentwire doctor # Auto-diagnose issues
agentwire safety status # Check protection status
agentwire hooks install # Install Claude Code hooks
agentwire network status # Service health check
```
</details>
---
## Documentation
- [Troubleshooting](docs/TROUBLESHOOTING.md)
- [Portal API](docs/PORTAL.md)
- [Remote Machines](docs/remote-machines.md)
- [RunPod TTS Setup](docs/runpod-tts.md)
- [Self-Hosted TTS](docs/tts-self-hosted.md)
- [Safety Hooks](docs/security/damage-control.md)
---
## Community
- [Discord](https://discord.gg/bspFZNTdUr) - Chat, support, feature requests
- [Issues](https://github.com/dotdevdotdev/agentwire-dev/issues) - Bug reports
- [Website](https://agentwire.dev) - Docs and demos
---
## License
**Dual-licensed:**
- [AGPL v3](LICENSE) - Free for open source
- Commercial license available - [contact us](mailto:dev@dotdev.dev)
---
<p align="center">
<strong>AgentWire: For people who have better things to do.</strong>
</p>
| text/markdown | null | dotdev <dev@dotdev.dev> | null | null | GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007 Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software. A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate. Many developers of free software are heartened and encouraged by the resulting cooperation. However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public. The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community. It requires the operator of a network server to provide the source code of the modified version running there to the users of that server. Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version. An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals. This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU Affero General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Remote Network Interaction; Use with the GNU General Public License. Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software. This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year> <name of author> This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. Also add information on how to contact you by electronic and paper mail. If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source. For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code. There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements. You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <https://www.gnu.org/licenses/>. | agent, ai, claude, stt, tmux, tts, voice | [
"Development Status :: 3 - Alpha",
"Environment :: Web Environment",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
"Operating System :: MacOS",
"Operating System :: POSIX :: Linux",
"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 :: Software Development :: User Interfaces"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"aiohttp-jinja2>=1.6",
"aiohttp>=3.9.0",
"jinja2>=3.1.0",
"markdown>=3.5",
"mcp>=1.2.0",
"python-dotenv>=1.0.0",
"pyyaml>=6.0",
"requests>=2.28.0",
"resend>=2.0.0",
"pytest-asyncio>=0.23.0; extra == \"dev\"",
"pytest>=7.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"fastapi>=0.104.0; extra == \"stt\"",
"faster-whisper>=1.0.0; extra == \"stt\"",
"python-multipart>=0.0.6; extra == \"stt\"",
"uvicorn>=0.24.0; extra == \"stt\"",
"chatterbox-tts>=0.1.6; extra == \"tts\"",
"fastapi>=0.104.0; extra == \"tts\"",
"faster-whisper>=1.0.0; extra == \"tts\"",
"pydantic>=2.0.0; extra == \"tts\"",
"python-multipart>=0.0.6; extra == \"tts\"",
"runpod>=1.6.0; extra == \"tts\"",
"torch>=2.0.0; extra == \"tts\"",
"torchaudio>=2.0.0; extra == \"tts\"",
"uvicorn>=0.24.0; extra == \"tts\""
] | [] | [] | [] | [
"Homepage, https://agentwire.dev",
"Repository, https://github.com/dotdevdotdev/agentwire-dev",
"Documentation, https://agentwire.dev",
"Issues, https://github.com/dotdevdotdev/agentwire-dev/issues",
"Changelog, https://github.com/dotdevdotdev/agentwire-dev/blob/main/CHANGELOG.md"
] | uv/0.7.20 | 2026-02-20T17:28:49.264401 | agentwire_dev-1.7.0.tar.gz | 31,428,487 | d8/a5/f772b1560ce60537a414fb312ba3e2d78fb1c7412993379ddc24db03b605/agentwire_dev-1.7.0.tar.gz | source | sdist | null | false | 14b34651d82d0d507f89636e41d318c2 | 977bc622f3eb7c0b88b5f0bad216a67740001f2fd622b8bcd9acad58c5672396 | d8a5f772b1560ce60537a414fb312ba3e2d78fb1c7412993379ddc24db03b605 | null | [
"LICENSE"
] | 210 |
2.4 | kdebug | 0.6.2 | TUI for Kubernetes Debug Containers | # kdebug - Universal Kubernetes Debug and File Copy Container Utility
Simple utility for launching ephemeral debug containers in Kubernetes pods with interactive shell access, backup capabilities, and a colorful TUI for pod selection.
Similar to [kpf](https://github.com/jessegoodier/kpf), this is a python wrapper around `kubectl debug` and `kubectl cp`.
>Notice: the default debug container image is <https://github.com/jessegoodier/toolbox/tree/main/common> and may not be ideal for all users. This is configurable both with an arg and a global config file
## Features
- 🐚 **Interactive Shell Access** - Launch bash/sh sessions in debug containers directly to the directory of your choice
- 💾 **Backup Capabilities** - Copy files/directories from pods with optional compression and configurable local paths
- 🔍 **Multiple Selection Modes** - Direct pod, controller-based, or interactive TUI
- 🎯 **Smart Container Selection** - Auto-select containers or choose specific targets
- 🔐 **Root Access Support** - Run debug containers as root when needed
- 📦 **Controller Support** - Works with Deployments, StatefulSets, and DaemonSets
- ⚙️ **Config File** - Set defaults for debug image, shell command, and backup paths
<details open>
<summary>Demo of the debug TUI</summary>
</details>
<details open>
<summary>Demo of backups</summary>
</details>
## Installation
```bash
brew install jessegoodier/kdebug/kdebug
```
## Usage
kdebug uses subcommands for its two modes of operation:
```
kdebug debug [options] # Interactive debug session (default)
kdebug backup [options] # Backup files from pod
kdebug [options] # Same as "kdebug debug" for convenience
```
### Global Options
These shared options work with both subcommands:
```bash
# Use a specific context
kdebug --context minikube -n default --pod my-pod
# Use a different kubeconfig file
kdebug --kubeconfig .kubeconfig -n openclaw
# Combine both options
kdebug --kubeconfig /path/to/config --context staging -n myapp --pod api-0
```
### Interactive Mode (TUI)
When no pod or controller is specified, kdebug launches an interactive menu system:
```bash
# Interactive mode - select from all resources in current namespace
kdebug
# Interactive mode with specific namespace
kdebug -n openclaw
```
### Debug Subcommand
The `debug` subcommand (or naked `kdebug`) launches an interactive shell session in an ephemeral debug container.
```bash
# Interactive session with direct pod (bare usage = debug)
kdebug -n kubecost --pod aggregator-0 --container aggregator
# Explicit debug subcommand with custom shell
kdebug debug -n kubecost --pod aggregator-0 --cmd sh
# Auto-select first container if not specified
kdebug debug -n kubecost --pod aggregator-0
# Change to a directory on start
kdebug debug -n kubecost --pod aggregator-0 --cd-into /var/configs
```
**Debug-specific options:**
| Option | Description |
|---|---|
| `--cmd CMD` | Command to run in debug container (default: `bash`) |
| `--cd-into DIR` | Change to directory on start (via `/proc/1/root`) |
### Controller-Based Selection
```bash
# Using StatefulSet (sts)
kdebug --controller sts/aggregator --container aggregator
# Using Deployment
kdebug -n myapp --controller deploy/frontend --cmd sh
# Using DaemonSet
kdebug -n logging --controller ds/fluentd
```
**Supported Controller Types:**
- `deployment` or `deploy` - Kubernetes Deployments
- `statefulset` or `sts` - StatefulSets
- `daemonset` or `ds` - DaemonSets
### Backup Subcommand
The `backup` subcommand copies files or directories from a pod to your local machine.
```bash
# Backup a directory (uncompressed)
kdebug backup -n kubecost --pod aggregator-0 --container-path /var/configs
# Backup with compression
kdebug backup -n kubecost --pod aggregator-0 --container-path /var/configs --compress
# Backup with a custom local path using template variables
kdebug backup --pod web-0 --container-path /var/data \
--local-path ./my-backups/{namespace}/{pod}
# Backup using controller selection
kdebug backup --controller deploy/kubecost-local-store \
--container-path /var/configs/localBucket_v002
```
**Backup-specific options:**
| Option | Description |
|---|---|
| `--container-path PATH` | **(required)** Path inside the container to back up |
| `--local-path TEMPLATE` | Local destination (default: `./backups/{namespace}/{date}_{pod}`) |
| `--compress` | Compress backup as tar.gz |
| `--tar-exclude PATH` | Exclude a path or pattern from the archive (repeatable) |
**Using `--tar-exclude`:**
Excludes are matched against paths inside the archive and can be repeated. Provide a name or relative pattern — **do not include the full container path prefix**:
```bash
# Exclude a single subdirectory by name
kdebug backup -n kubecost --pod aggregator-0 --container-path /var/configs \
--compress --tar-exclude waterfowl
# Exclude multiple paths
kdebug backup -n kubecost --pod aggregator-0 --container-path /var/configs \
--compress --tar-exclude waterfowl --tar-exclude tmp --tar-exclude '*.log'
```
**Template variables for `--local-path`:**
| Variable | Value |
|---|---|
| `{namespace}` | Kubernetes namespace |
| `{pod}` | Pod name |
| `{date}` | Timestamp (`YYYY-MM-DD_HH-MM-SS`) |
| `{container}` | Target container name |
### Run as Root
```bash
# Launch debug container as root user
kdebug -n myapp --pod frontend-abc123 --as-root
```
### Verbose Mode
```bash
# Show all kubectl commands being executed
kdebug -n myapp --pod frontend-abc123 --verbose
```
## Config File
kdebug supports a JSON config file at `~/.config/kdebug/kdebug.json` (respects `XDG_CONFIG_HOME`). CLI flags always take priority over config values.
```json
{
"debugImage": "busybox:latest",
"cmd": "sh",
"cdInto": "/app",
"backupContainerPath": "/var/data",
"backupLocalPath": "./backups/{namespace}/{date}_{pod}"
}
```
| Key | Description | Default |
|---|---|---|
| `debugImage` | Debug container image | `ghcr.io/jessegoodier/toolbox-common:latest` |
| `cmd` | Shell command for debug sessions | `bash` |
| `cdInto` | Directory to cd into on start | *(none)* |
| `backupContainerPath` | Default container path for backups | *(none)* |
| `backupLocalPath` | Default local path template for backups | `./backups/{namespace}/{date}_{pod}` |
String values support `${ENV_VAR}` expansion:
```json
{
"debugImage": "${MY_DEBUG_IMAGE}",
"backupLocalPath": "${HOME}/kdebug-backups/{namespace}/{date}_{pod}"
}
```
### Example: Using busybox as debug image
If you don't need the full toolbox image, busybox is a lightweight alternative:
```json
{
"debugImage": "busybox:latest",
"cmd": "sh"
}
```
Since busybox doesn't include bash, set `cmd` to `sh`. With this config, simply run `kdebug --pod my-pod` and it will use busybox with sh automatically.
## Shell Completion
kdebug supports tab completion for bash and zsh with dynamic lookups for namespaces, pods, controller names, and subcommands.
### Bash
```bash
# Add to ~/.bashrc
source <(kdebug --completions bash)
# Or source the file directly
source /path/to/kdebug/completions/kdebug.bash
```
### Zsh
```bash
# Option 1: Source directly (add to ~/.zshrc)
source <(kdebug --completions zsh)
# Option 2: Install to fpath (recommended)
mkdir -p ~/.zsh/completions
kdebug --completions zsh > ~/.zsh/completions/_kdebug
# Add to ~/.zshrc before compinit:
fpath=(~/.zsh/completions $fpath)
autoload -Uz compinit && compinit
```
### Completion Features
- `kdebug <TAB>` - Complete subcommands (`debug`, `backup`)
- `kdebug --<TAB>` - Complete shared options
- `kdebug debug --<TAB>` - Complete debug-specific options
- `kdebug backup --<TAB>` - Complete backup-specific options
- `kdebug -n <TAB>` - Complete namespace names from cluster
- `kdebug --pod <TAB>` - Complete pod names (respects -n flag)
- `kdebug --controller <TAB>` - Complete controller types and names
- `kdebug --context <TAB>` - Complete context names from kubeconfig
## Examples
### Example 1: Interactive Pod Selection
```bash
$ kdebug -n production
Starting interactive pod selection...
══════════════════════════════════════════════════════════════════════
Select Pod in namespace: production
══════════════════════════════════════════════════════════════════════
▶ 1. frontend-abc123 (Running)
2. frontend-def456 (Running)
3. backend-ghi789 (Running)
4. database-0 (Running)
5. worker-jkl012 (Pending)
──────────────────────────────────────────────────────────────────────
Use ↑/↓ arrows or numbers to select, Enter to confirm, q to quit
──────────────────────────────────────────────────────────────────────
```
### Example 2: Quick Debug Session
```bash
# Launch debug container and get bash shell
kdebug -n kubecost --controller sts/aggregator --container aggregator
# Output:
# ══════════════════════════════════════════════════════════════════════
# Starting interactive session in pod aggregator-0
# Container: debugger-xyz
# Command: bash
# ══════════════════════════════════════════════════════════════════════
```
### Example 3: Backup with Custom Local Path
```bash
# Backup with compression to a custom path
kdebug backup -n production --pod api-server-0 \
--container-path /etc/app/config \
--local-path ./config-backups/{namespace}/{date}_{pod} \
--compress
# Output:
# ══════════════════════════════════════════════════════════════════════
# Creating backup from pod api-server-0
# Container path: /etc/app/config
# Local path: ./config-backups/production/2024-02-04_10-30-45_api-server-0.tar.gz
# Mode: Compressed (tar.gz)
# ══════════════════════════════════════════════════════════════════════
# ✓ Path exists: /etc/app/config
# ✓ Backup archive created
# ✓ Backup saved to: ./config-backups/production/2024-02-04_10-30-45_api-server-0.tar.gz
```
## Color Scheme
kdebug uses a kubecolor-inspired color scheme:
- 🔵 **Blue** - Borders and separators
- 🟢 **Green** - Success messages and running status
- 🟡 **Yellow** - Warnings and pending status
- 🔴 **Red** - Errors and failed status
- 🟣 **Magenta** - Namespaces
- 🔷 **Cyan** - Pod and container names
- ⚪ **White/Gray** - General text and metadata
## Requirements
- Python 3.9+
- kubectl configured with cluster access
- Kubernetes cluster with ephemeral containers support (v1.23+)
## How It Works
1. **Resource Discovery** - Queries Kubernetes API for controllers/pods
2. **Debug Container Launch** - Creates ephemeral container with debug image
3. **Process Sharing** - Enables `--share-processes` for full pod access
4. **Interactive Session** - Attaches to container with TTY
5. **Cleanup** - Terminates debug container after session ends
## Troubleshooting
### "Operation not supported on socket" Error
The interactive TUI requires a real terminal (TTY). Ensure you're running kdebug in:
- A standard terminal (not piped or redirected)
- Not through automation tools that don't provide TTY
- With proper terminal emulation support
### "Pod Security Policy" Warnings
If you see warnings about `runAsNonRoot`, the pod has security restrictions. Try:
- Running without `--as-root` flag
- Checking pod security policies
- Using a different debug image
### Container Won't Start
Check:
- Debug image is accessible from cluster
- Pod has sufficient resources
- Network policies allow image pull
- Use `--verbose` flag to see kubectl commands
## License
MIT
## Contributing
Contributions welcome! Please open issues or pull requests.
---
Made with ❤️ and Bob
| text/markdown | Jesse Goodier | null | null | null | null | cli, debug, kubectl, kubernetes | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"License :: OSI Approved :: MIT License",
"Operating System :: MacOS",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"rich>=14.0"
] | [] | [] | [] | [
"Homepage, https://github.com/jessegoodier/kdebug",
"Repository, https://github.com/jessegoodier/kdebug"
] | 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-20T17:28:36.993759 | kdebug-0.6.2.tar.gz | 23,052 | 2c/4f/a5085e488c18d8c8490b9593c751fa88ff8da90e0892ff2a54afb43fcc63/kdebug-0.6.2.tar.gz | source | sdist | null | false | 686789d84920913bcff21627768549d7 | d4ef180a0071db137de2978f77b15a3eca9ae64b283c4cd3ae1904927db9ae18 | 2c4fa5085e488c18d8c8490b9593c751fa88ff8da90e0892ff2a54afb43fcc63 | MIT | [] | 225 |
2.4 | william-occam | 0.2.3.1 | William: A tool for data compression and machine learning automatization | [](https://gitlab.com/occam_ua/william/-/commits/master)
[](https://pypi.org/project/william-occam/)
# WILLIAM - A general purpose data compression algorithm
## Overview
WILLIAM is an **inductive programming system** based on the
**theory of Incremental Compression (IC)** [Franz et al. 2021].
Its core principle is that *learning = compression*:
given a dataset `x`, the algorithm searches for short descriptions in the form
of compositional features `f1, f2, …, fs` such that
x = f1(f2(... f_s(r_s)))
with each step achieving some compression.
This corresponds to an incremental approximation of the **Kolmogorov complexity K(x)**:
K(x) ≈ Σ l(f*i) + K(r_s) + O(s · log l(x))
where each `f*i` is the shortest compressing feature at step `i`.
WILLIAM differs from classical ML approaches in that it does not optimize
parameters in a fixed representation, but **searches a broad algorithmic space**
for compressing autoencoders.
This yields machine learning algorithms (centralization, regression, classification, decision trees, outlier detection) as *emergent special cases* of general compression:contentReference[oaicite:0]{index=0}.
For theoretical background, see:
- *A Theory of Incremental Compression* (Franz, Antonenko, Soletskyi, 2021):contentReference[oaicite:1]{index=1}
- *WILLIAM: A Monolithic Approach to AGI* (Franz, Gogulya, Löffler, 2019)
- *Experiments on the Generalization of Machine Learning Algorithms* (Franz, 2020):contentReference[oaicite:2]{index=2}
## Key Concepts
- **Incremental Compression**
Decomposes data into *features* and *residuals* step by step, ensuring that each feature is independent and incompressible.
- **Features as Properties**
Features formalize algorithmic properties of data and can be related to **Martin-Löf randomness tests**:
non-random regularities correspond to compressible features.
- **Universality**
Unlike specialized ML algorithms, WILLIAM discovers short descriptions exhaustively
via directed acyclic graphs (DAGs) of operators, reusing values and cutting at information bottlenecks.
- **Emergent ML Algorithms**
Without any tuning, WILLIAM naturally rediscovers:
- data centralization
- outlier detection
- linear regression
- linear classification
- decision tree induction:contentReference[oaicite:3]{index=3}
## Limitations and Future Work
Overhead accumulation: IC theory implies additive overhead terms.
Alternative descriptions: currently only one compression path is explored at a time.
Reuse of functions: theory of memory/retrieval still open.
Performance: the Python prototype handles graphs of depth 4–5; C++/Rust backend and parallelization are natural next steps.
Despite these challenges, IC theory provides guarantees:
incremental compression reaches Kolmogorov complexity up to logarithmic precision
## Installation
For a standard installation, use:
```
pip install william-occam
```
For a full installation of all dependencies for further development, testing and graphical output use:
```
pip install william-occam[dev]
```
## Compression examples
You can run various compression tests directly with **pytest**. Set
```
export WILLIAM_DEBUG=3
```
to get visual output after every compression step. Set to 2, if you only want to see the compression results after every task.
Now run:
```bash
py.test -v -s william/tests/test_alice.py
```
Enter c and enter to step through the steps with the debugger and look at the generated graphs.
During execution, WILLIAM will:
- Generate synthetic training data for several regression problems:
- Search for a minimal program (tree/DAG) that explains the data.
- Display the compression progress (how the description length decreases).
- Render the resulting Directed Acyclic Graphs (DAGs) as PDF files in your working directory.
## License
This project is licensed under the Creative Commons Attribution-NonCommercial 4.0 International License (CC BY-NC 4.0). You are free to use, share, and modify the code for non-commercial purposes only, with proper attribution to the original author. For full license details, see the [LICENSE.md](./LICENSE.md) file.
## Releasing
Releases are published automatically when a tag is pushed to GitLab.
```bash
# Example for version 1.2.3
export RELEASE=v1.2.3
# Create a tag and push the specific tag to trigger the CI pipeline
git tag $RELEASE && git push origin $RELEASE
```
| text/markdown; charset=UTF-8; variant=GFM | null | Arthur Franz <af@occam.com.ua>, Michael Löffler <ml@occam.com.ua> | null | null | null | artificial intelligence, machine learning, incremental compression, data compression, inductive programming, AGI | [
"Development Status :: 4 - Beta",
"Intended Audience :: Science/Research",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"License :: Free for non-commercial use",
"Topic :: Scientific/Engineering",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"numpy",
"numba",
"pandas",
"intnan",
"typing-inspect",
"scikit-learn",
"xxhash",
"scipy; extra == \"dev\"",
"graphviz; extra == \"dev\"",
"pillow; extra == \"dev\"",
"uvicorn; extra == \"web\"",
"fastapi; extra == \"web\"",
"jinja2; extra == \"web\"",
"email-validator; extra == \"web\"",
"python-multipart; extra == \"web\"",
"python-dotenv; extra == \"web\"",
"starlette; extra == \"web\""
] | [] | [] | [] | [
"homepage, https://occam.com.ua",
"source, https://gitlab.com/occam_ua/william/",
"tracker, https://gitlab.com/occam_ua/william/-/issues"
] | uv/0.10.0 {"installer":{"name":"uv","version":"0.10.0","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Debian GNU/Linux","version":"13","id":"trixie","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-20T17:28:02.126145 | william_occam-0.2.3.1-cp313-cp313-manylinux_2_34_x86_64.whl | 2,766,141 | ee/1f/c752403358b7dbbdbb8bac607419b4e17c03e0d8429f18e25d75f2e769c2/william_occam-0.2.3.1-cp313-cp313-manylinux_2_34_x86_64.whl | cp313 | bdist_wheel | null | false | 7635289ffe19f7dc43a22f2eef9f6a84 | 735e69a962d673207b69185b4211fed8db12526441315861ac5ed1a9d075927f | ee1fc752403358b7dbbdbb8bac607419b4e17c03e0d8429f18e25d75f2e769c2 | null | [
"LICENSE.md"
] | 272 |
2.4 | langchain-nativ | 0.1.0 | LangChain integration for Nativ — AI-powered localization tools | # langchain-nativ
[](https://pypi.org/project/langchain-nativ/)
[](LICENSE)
[LangChain](https://www.langchain.com/) integration for **[Nativ](https://usenativ.com)** — AI-powered localization.
Give any LangChain agent the ability to translate text, search translation memory, manage terminology, and more — all backed by your team's brand voice and style guides.
## Installation
```bash
pip install langchain-nativ
```
## Quick start
```python
from langchain_nativ import NativTranslateTool
tool = NativTranslateTool() # reads NATIV_API_KEY from env
result = tool.invoke({
"text": "Hello world",
"target_language": "French",
})
print(result)
# Bonjour le monde
# Rationale: Standard greeting translated with neutral register.
```
## Use with a LangChain agent
```python
from langchain_nativ import NativToolkit
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
tools = NativToolkit().get_tools()
llm = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(llm, tools)
result = agent.invoke({
"messages": [{
"role": "user",
"content": "Translate 'Welcome back!' to French, German, and Japanese",
}]
})
```
## Available tools
| Tool | Description |
|------|-------------|
| `NativTranslateTool` | Translate text with cultural adaptation |
| `NativTranslateBatchTool` | Translate multiple texts to one language |
| `NativSearchTranslationMemoryTool` | Fuzzy-search existing translations |
| `NativAddTranslationMemoryEntryTool` | Store an approved translation for reuse |
| `NativGetLanguagesTool` | List configured target languages |
| `NativGetStyleGuidesTool` | Get style guide content |
| `NativGetBrandVoiceTool` | Get the brand voice prompt |
| `NativGetTranslationMemoryStatsTool` | Get TM statistics |
## Configuration
All tools accept `api_key` and `base_url` parameters:
```python
tool = NativTranslateTool(api_key="nativ_...", base_url="https://api.usenativ.com")
```
Or set the environment variable:
```bash
export NATIV_API_KEY=nativ_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
```
## Use individual tools
```python
from langchain_nativ import NativSearchTranslationMemoryTool
search = NativSearchTranslationMemoryTool()
print(search.invoke({"query": "Welcome"}))
# Found 3 match(es):
# - [98% exact] "Welcome" → "Bienvenue"
# - [85% fuzzy] "Welcome back" → "Content de vous revoir"
# ...
```
## License
MIT
| text/markdown | null | Nativ <hello@usenativ.com> | null | null | null | ai, i18n, l10n, langchain, localization, nativ, translation | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"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",
"Programming Language :: Python :: 3.13",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Localization",
"Typing :: Typed"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"langchain-core>=0.3.0",
"nativ>=0.1.0",
"pytest-asyncio>=0.21; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://usenativ.com",
"Documentation, https://docs.usenativ.com",
"Repository, https://github.com/Nativ-Technologies/langchain-nativ",
"Issues, https://github.com/Nativ-Technologies/langchain-nativ/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:27:35.520759 | langchain_nativ-0.1.0.tar.gz | 8,598 | 05/72/11e56795f58bace21c34dcf05d679d92994dcbd6788d04e7e38e69460bfd/langchain_nativ-0.1.0.tar.gz | source | sdist | null | false | d39a03f885bd0e9f0633ee7b600845ad | bc227b1dc4d868a656fd5fc565b3b507046829b88b0ce711437eddccb87b64df | 057211e56795f58bace21c34dcf05d679d92994dcbd6788d04e7e38e69460bfd | MIT | [
"LICENSE"
] | 214 |
2.4 | pycytominer | 1.4.0 | Python package for processing image-based profiling data | <img height="200" src="https://raw.githubusercontent.com/cytomining/pycytominer/main/logo/with-text-for-light-bg.png?raw=true">
# Data processing for image-based profiling
[](https://github.com/cytomining/pycytominer/actions/workflows/integration-test.yml?query=branch%3Amain)
[](https://codecov.io/github/cytomining/pycytominer?branch=main)
[](https://github.com/astral-sh/ruff)
[](https://pycytominer.readthedocs.io/)
[](https://doi.org/10.1038/s41592-025-02611-8)
Pycytominer is a suite of common functions used to process high dimensional readouts from high-throughput cell experiments.
The tool is most often used for processing data through the following pipeline:
<img height="700" align="center" alt="Description of the Pycytominer pipeline. Images flow from feature extraction and are processed with a series of steps" src="https://github.com/cytomining/pycytominer/blob/main/media/pipeline.png?raw=true">
> Figure 1. The standard image-based profiling experiment and the role of Pycytominer. (A) In the experimental phase, a scientist plates cells, often perturbing them with chemical or genetic agents and performs microscopy imaging. In image analysis, using CellProfiler for example, a scientist applies several data processing steps to generate image-based profiles. In addition, scientists can apply a more flexible approach by using deep learning models, such as DeepProfiler, to generate image-based profiles. (B) Pycytominer performs image-based profiling to process morphology features and make them ready for downstream analyses. (C) Pycytominer performs five fundamental functions, each implemented with a simple and intuitive API. Each function enables a user to implement various methods for executing operations.
[Click here for high resolution pipeline image](https://github.com/cytomining/pycytominer/blob/main/media/pipeline.png)
Image data flow from a microscope to cell segmentation and feature extraction tools (e.g. [CellProfiler](https://cellprofiler.org/) or [DeepProfiler](https://cytomining.github.io/DeepProfiler-handbook/docs/00-welcome.html)) (**Figure 1A**).
From here, additional single cell processing tools curate the single cell readouts into a form manageable for Pycytominer input.
For [CellProfiler](https://cellprofiler.org/), we use [cytominer-database](https://github.com/cytomining/cytominer-database) or [CytoTable](https://github.com/cytomining/CytoTable).
For [DeepProfiler](https://cytomining.github.io/DeepProfiler-handbook/docs/00-welcome.html), we include single cell processing tools in [pycytominer.cyto_utils](pycytominer/cyto_utils/).
Next, Pycytominer performs reproducible image-based profiling (**Figure 1B**).
The Pycytominer API consists of five key steps (**Figure 1C**).
The outputs generated by Pycytominer are utilized for downstream analysis, which includes machine learning models and statistical testing to derive biological insights.
The best way to communicate with us is through [GitHub Issues](https://github.com/cytomining/pycytominer/issues), where we are able to discuss and troubleshoot topics related to pycytominer.
Please see our [`CONTRIBUTING.md`](https://github.com/cytomining/pycytominer/blob/main/CONTRIBUTING.md) for details about communicating possible bugs, new features, or other information.
## Installation
You can install Pycytominer using the following platforms.
This project follows a `<major>.<minor>.<patch>` semantic versioning scheme which is used for every release with small variations per platform.
**pip** ([link](https://pypi.org/project/pycytominer/)):
```bash
# install pycyotminer from PyPI
pip install pycytominer
```
**conda** ([link](https://anaconda.org/conda-forge/pycytominer)):
```bash
# install Pycytominer from conda-forge
conda install -c conda-forge pycytominer
```
**Docker Hub** ([link](https://hub.docker.com/r/cytomining/pycytominer)):
Container images of Pycytominer are made available through Docker Hub.
These images follow a tagging scheme that extends our release sematic versioning which may be found within our [`CONTRIBUTING.md` Docker Hub Image Releases](https://github.com/cytomining/pycytominer/blob/main/CONTRIBUTING.md#docker-hub-image-releases) documentation.
```bash
# pull the latest Pycytominer image and run a module
docker run --platform=linux/amd64 cytomining/pycytominer:latest python -m pycytominer.<modules go here>
# pull a commit-based version of Pycytominer (b1bb292) and run an interactive bash session within the container
docker run -it --platform=linux/amd64 cytomining/pycytominer:pycytominer-1.1.0.post16.dev0_b1bb292 bash
# pull a scheduled update of pycytominer, map the present working directory to /opt within the container, and run a python script.
docker run -v $PWD:/opt --platform=linux/amd64 cytomining/pycytominer:pycytominer-1.1.0.post16.dev0_b1bb292_240417 python /opt/script.py
```
## Frameworks
Pycytominer is primarily built on top of [pandas](https://pandas.pydata.org/docs/index.html), also using aspects of SQLAlchemy, sklearn, and pyarrow.
Pycytominer currently supports [parquet](https://parquet.apache.org/), compressed text (e.g. `.csv.gz`), and [`anndata`](https://github.com/scverse/anndata) (through the extra `pip install pycytominer[anndata]` and limited to `h5ad` or `zarr`) input and output data.
### CellProfiler support
Currently, Pycytominer fully supports data generated by [CellProfiler](https://cellprofiler.org/), adhering defaults to its specific data structure and naming conventions.
CellProfiler-generated image-based profiles typically consist of two main components:
- **Metadata features:** This section contains information about the experiment, such as plate ID, well position, incubation time, perturbation type, and other relevant experimental details. These feature names are prefixed with `Metadata_`, indicating that the data in these columns contain metadata information.
- **Morphology features:** These are the quantified morphological features prefixed with the default compartments (`Cells_`, `Cytoplasm_`, and `Nuclei_`). Pycytominer also supports non-default compartment names (e.g., `Mito_`).
Note, [`pycytominer.cyto_utils.cells.SingleCells()`](pycytominer/cyto_utils/cells.py) contains code designed to interact with single-cell SQLite files exported from CellProfiler.
Processing capabilities for SQLite files depends on SQLite file size and your available computational resources (for ex. memory and CPU).
### Handling inputs from other image analysis tools (other than CellProfiler)
We recommend pre-harmonizing data using [CytoTable](https://github.com/cytomining/CytoTable) when working with data from image analysis tools such as [CellProfiler](https://cellprofiler.org/), [In Carta](https://www.moleculardevices.com/products/cellular-imaging-systems/high-content-analysis/in-carta-image-analysis-software), or legacy data systems such as cytominer-database.
CytoTable is purpose-built to help prepare data for Pycytominer and includes many presets to help you get started with your work (please also check out our [CytoTable preprint](https://doi.org/10.1101/2025.06.19.660613)).
For example, to resolve potential feature issues in the `normalize()` function, you must manually specify the morphological features using the `features` [parameter](https://pycytominer.readthedocs.io/en/latest/pycytominer.html#pycytominer.normalize.normalize).
The `features` parameter is also available in other key steps, such as [`aggregate`](https://pycytominer.readthedocs.io/en/latest/pycytominer.html#pycytominer.aggregate.aggregate) and [`feature_select`](https://pycytominer.readthedocs.io/en/latest/pycytominer.html#pycytominer.feature_select.feature_select).
If you are using Pycytominer with these other tools, please file [an issue](https://github.com/cytomining/pycytominer/issues) to reach out.
We'd love to hear from you so that we can learn how to best support broad and multiple use-cases.
## API
Pycytominer has five major processing functions:
1. Aggregate - Average single-cell profiles based on metadata information (most often "well").
2. Annotate - Append metadata (most often from the platemap file) to the feature profile
3. Normalize - Transform input feature data into consistent distributions
4. Feature select - Exclude non-informative or redundant features
5. Consensus - Average aggregated profiles by replicates to form a "consensus signature"
The API is consistent for each of these functions:
```python
# Each function takes as input a pandas DataFrame or file path
# and transforms the input data based on the provided options and methods
df = function(
profiles_or_path,
features,
samples,
method,
output_file,
additional_options...
)
```
Each processing function has unique arguments, see our [documentation](https://pycytominer.readthedocs.io/) for more details.
## Usage
The default way to use Pycytominer is within python scripts, and using Pycytominer is simple and fun.
The example below demonstrates how to perform normalization with a dataset generated by [CellProfiler](https://cellprofiler.org/).
```python
# Real world example
import pandas as pd
import pycytominer
commit = "da8ae6a3bc103346095d61b4ee02f08fc85a5d98"
url = f"https://media.githubusercontent.com/media/broadinstitute/lincs-cell-painting/{commit}/profiles/2016_04_01_a549_48hr_batch1/SQ00014812/SQ00014812_augmented.csv.gz"
df = pd.read_csv(url)
normalized_df = pycytominer.normalize(
profiles=df,
method="standardize",
samples="Metadata_broad_sample == 'DMSO'"
)
```
### Command Line Interface (CLI) usage
Pycytominer also provides a simple CLI for file-based workflows.
The Pycytominer CLI calls single Pycytominer functions that read profiles from disk, perform a specific operation with provided arguments, and write outputs to disk without requiring a dedicated python file.
Before using the CLI, keep in mind the following conventions:
- The CLI is intended for file-based execution of the core processing functions:
`aggregate`, `annotate`, `normalize`, `feature_select`, and `consensus`.
- Arguments that map to Python lists (for example `--features`, `--strata`,
`--replicate_columns`, and `--operation`) should be passed as comma-delimited
strings.
- The CLI executes one Pycytominer function per command and writes results to
disk. For full pipeline orchestration, chain commands in your workflow manager.
- Output format is controlled by `--output_type` (for example `parquet`); this is
not inferred from the filename extension.
```bash
# Aggregate profiles (note the parquet output type)
pycytominer aggregate \
--profiles path/to/profiles.csv.gz \
--output_file path/to/profiles_aggregated.parquet \
--output_type parquet \
--strata Metadata_Plate,Metadata_Well \
--features Cells_AreaShape_Area,Cytoplasm_AreaShape_Area
# Annotate profiles with platemap metadata
pycytominer annotate \
--profiles path/to/profiles_aggregated.parquet \
--platemap path/to/platemap.csv \
--output_type parquet \
--output_file path/to/profiles_augmented.parquet \
--join_on Metadata_well_position,Metadata_Well
# Normalize profiles
pycytominer normalize \
--profiles path/to/profiles_augmented.csv.gz \
--output_file path/to/profiles_normalized.parquet \
--output_type parquet \
--features Cells_AreaShape_Area,Cytoplasm_AreaShape_Area \
--meta_features Metadata_Plate,Metadata_Well \
--samples "Metadata_treatment == 'control'" \
--method standardize
# Feature selection
pycytominer feature_select \
--profiles path/to/profiles_normalized.parquet \
--output_file path/to/profiles_feature_selected.parquet \
--output_type parquet
--features Cells_AreaShape_Area,Cytoplasm_AreaShape_Area \
--operation variance_threshold,correlation_threshold
# Form consensus profiles
pycytominer consensus \
--profiles path/to/profiles_feature_selected.csv.gz \
--output_file path/to/profiles_consensus.parquet \
--output_type parquet \
--replicate_columns Metadata_Plate,Metadata_Well \
--features Cells_AreaShape_Area,Cytoplasm_AreaShape_Area \
--operation median
```
### Pipeline orchestration
Pycytominer is a collection of different functions with no explicit link between steps.
However, some options exist to use Pycytominer within a pipeline framework.
| Project | Format | Environment | Pycytominer usage |
| :------------------------------------------------------------------------------- | :-------- | :------------------- | :---------------------- |
| [Profiling-recipe](https://github.com/cytomining/profiling-recipe) | yaml | agnostic | full pipeline support |
| [CellProfiler-on-Terra](https://github.com/broadinstitute/cellprofiler-on-Terra) | WDL | google cloud / Terra | single-cell aggregation |
| [CytoSnake](https://github.com/WayScience/CytoSnake) | snakemake | agnostic | full pipeline support |
A separate project called [AuSPICES](https://github.com/broadinstitute/AuSPICEs) offers pipeline support up to image feature extraction.
## Other functionality
Pycytominer was written with a goal of processing any high-throughput image-based profiling data.
However, the initial use case was developed for processing image-based profiling experiments specifically.
And, more specifically than that, image-based profiling readouts from [CellProfiler](https://github.com/CellProfiler) measurements from [Cell Painting](https://www.nature.com/articles/nprot.2016.105) data.
Therefore, we have included some custom tools in `pycytominer/cyto_utils` that provides other functionality:
### CellProfiler CSV collation
If running your images on a cluster, unless you have a MySQL or similar large database set up then you will likely end up with lots of different folders from the different cluster runs (often one per well or one per site), each one containing an `Image.csv`, `Nuclei.csv`, etc.
In order to look at full plates, therefore, we first need to collate all of these CSVs into a single file (currently SQLite) per plate.
We currently do this with a library called [cytominer-database](https://github.com/cytomining/cytominer-database).
If you want to perform this data collation inside Pycytominer using the `cyto_utils` function `collate` (and/or you want to be able to run the tests and have them all pass!), you will need `cytominer-database==0.3.4`; this will change your installation commands slightly:
```bash
# Example for general case commit:
pip install "pycytominer[collate]"
# Example for specific commit:
pip install "pycytominer[collate] @ git+https://github.com/cytomining/pycytominer@77d93a3a551a438799a97ba57d49b19de0a293ab"
```
If using `pycytominer` in a conda environment, in order to run `collate.py`, you will also want to make sure to add `cytominer-database=0.3.4` to your list of dependencies.
### Creating a cell locations lookup table
The `CellLocation` class offers a convenient way to augment a [LoadData](https://cellprofiler-manual.s3.amazonaws.com/CPmanual/LoadData.html) file with X,Y locations of cells in each image.
The locations information is obtained from a single cell SQLite file.
To use this functionality, you will need to modify your installation command, similar to above:
```bash
# Example for general case commit:
pip install "pycytominer[cell_locations]"
```
Example using this functionality:
```bash
metadata_input="s3://cellpainting-gallery/test-cpg0016-jump/source_4/workspace/load_data_csv/2021_08_23_Batch12/BR00126114/test_BR00126114_load_data_with_illum.parquet"
single_single_cell_input="s3://cellpainting-gallery/test-cpg0016-jump/source_4/workspace/backend/2021_08_23_Batch12/BR00126114/test_BR00126114.sqlite"
augmented_metadata_output="~/Desktop/load_data_with_illum_and_cell_location_subset.parquet"
python \
-m pycytominer.cyto_utils.cell_locations_cmd \
--metadata_input ${metadata_input} \
--single_cell_input ${single_single_cell_input} \
--augmented_metadata_output ${augmented_metadata_output} \
add_cell_location
# Check the output
python -c "import pandas as pd; print(pd.read_parquet('${augmented_metadata_output}').head())"
# It should look something like this (depends on the width of your terminal):
# Metadata_Plate Metadata_Well Metadata_Site ... PathName_OrigRNA ImageNumber CellCenters
# 0 BR00126114 A01 1 ... s3://cellpainting-gallery/cpg0016-jump/source_... 1 [{'Nuclei_Location_Center_X': 943.512129380054...
# 1 BR00126114 A01 2 ... s3://cellpainting-gallery/cpg0016-jump/source_... 2 [{'Nuclei_Location_Center_X': 29.9516027655562...
```
### Generating a GCT file for morpheus
The software [morpheus](https://software.broadinstitute.org/morpheus/) enables profile visualization in the form of interactive heatmaps.
Pycytominer can convert profiles into a `.gct` file for drag-and-drop input into morpheus.
```python
# Real world example
import pandas as pd
import pycytominer
commit = "da8ae6a3bc103346095d61b4ee02f08fc85a5d98"
plate = "SQ00014812"
url = f"https://media.githubusercontent.com/media/broadinstitute/lincs-cell-painting/{commit}/profiles/2016_04_01_a549_48hr_batch1/{plate}/{plate}_normalized_feature_select.csv.gz"
df = pd.read_csv(url)
output_file = f"{plate}.gct"
pycytominer.cyto_utils.write_gct(
profiles=df,
output_file=output_file
)
```
## Citing Pycytominer
If you use `pycytominer` in your project, please cite our software.
You can see citation information in the 'cite this repository' link at the top right under `about` section within GitHub.
This information may also be referenced within the [`CITATION.cff`](CITATION.cff) file.
| text/markdown | Erik Serrano | null | Gregory P. Way | gregory.way@cuanschutz.edu | BSD-3-Clause | null | [
"License :: OSI Approved :: BSD 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",
"Programming Language :: Python :: 3.14"
] | [] | null | null | <3.15,>=3.10 | [] | [] | [] | [
"anndata<0.12.2; python_version < \"3.11\" and extra == \"anndata\"",
"anndata>=0.12.2; python_version >= \"3.11\" and extra == \"anndata\"",
"boto3>=1.26.79; extra == \"cell-locations\"",
"cytominer-database==0.3.4; extra == \"collate\"",
"fire>=0.5.0",
"fsspec>=2023.1.0; extra == \"cell-locations\"",
"numpy>=1.16.5",
"pandas>=1.2.0",
"pyarrow>=8.0.0",
"s3fs>=2023.4.0; extra == \"cell-locations\"",
"scikit-learn>=0.21.2",
"scipy>1.13.1; python_full_version > \"3.12.0\"",
"scipy>=1.5; python_version < \"3.13\"",
"sqlalchemy<3,>=1.3.6",
"zarr<3.1.1; python_version < \"3.11\" and extra == \"anndata\"",
"zarr>=3.1.1; python_version >= \"3.11\" and extra == \"anndata\""
] | [] | [] | [] | [
"Homepage, https://pycytominer.readthedocs.io/",
"Repository, https://github.com/cytomining/pycytominer"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:27:29.767948 | pycytominer-1.4.0.tar.gz | 207,131 | 5f/3c/c1ae72885690b98873fd718ae32ac4cbd31b9ed2658182eee183caff823e/pycytominer-1.4.0.tar.gz | source | sdist | null | false | 10f2988abeefe39b38dd92c4ca636219 | b969bd371d11abf74a5175e61616453c5d67f1bd56913e312a60b4464a618ef5 | 5f3cc1ae72885690b98873fd718ae32ac4cbd31b9ed2658182eee183caff823e | null | [
"LICENSE.md"
] | 209 |
2.4 | codetrust | 2.7.0 | AI code safety platform — 280 rules, 10 enforcement layers, 5 enterprise services. AI Governance Gateway blocks destructive AI agent actions (76 real-time rules). Hallucination Detection verifies imports against PyPI/npm/crates.io/Go/Maven/NuGet/RubyGems/Packagist. Trust Score tracks safety drift. CVE scanning, license compliance, cross-file analysis, auto-fix PRs, RBAC. 45 API endpoints, 21 MCP tools, 1898 tests. CLI, VS Code extension, GitHub Action, MCP server. | <p align="center">
<img src="https://codetrust.ai/logo.png" alt="CodeTrust — AI Governance Enforcement Platform" width="420">
</p>
<p align="center">
<strong>AI Governance Enforcement Platform — Prevent unsafe AI-generated code from reaching production.</strong>
</p>
<p align="center">
<code>Current: v2.7.0</code> · <code>1898 tests</code> · <code>280 rules</code> · <code>10 layers</code>
</p>
<p align="center">
<a href="https://pypi.org/project/codetrust/"><img src="https://img.shields.io/pypi/v/codetrust?style=flat-square&color=38d8fd" alt="PyPI"></a>
<a href="https://marketplace.visualstudio.com/items?itemName=SaidBorna.codetrust"><img src="https://img.shields.io/visual-studio-marketplace/v/SaidBorna.codetrust?style=flat-square&color=5bca78" alt="VS Code Marketplace"></a>
<a href="https://github.com/marketplace/actions/codetrust-scan"><img src="https://img.shields.io/badge/GitHub_Action-available-333?style=flat-square" alt="GitHub Action"></a>
<a href="LICENSE"><img src="https://img.shields.io/badge/License-Proprietary-333?style=flat-square" alt="License"></a>
</p>
<p align="center">
<a href="https://codetrust.ai">Website</a> ·
<a href="https://api.codetrust.ai/docs">API Docs</a> ·
<a href="https://pypi.org/project/codetrust/">PyPI</a> ·
<a href="https://marketplace.visualstudio.com/items?itemName=SaidBorna.codetrust">VS Code</a> ·
<a href="https://github.com/marketplace/actions/codetrust-scan">GitHub Action</a> ·
<a href="CHANGELOG.md">Changelog</a>
</p>
---
## What CodeTrust Is
**AI Governance Enforcement Platform** — 280 rules across 10 enforcement layers, 21 MCP tools, 45 API endpoints. 5 enterprise services: CVE/vulnerability scanning, license compliance, cross-file analysis, auto-fix PRs, and team management with RBAC. 1,898 tests.
CodeTrust prevents unsafe, hallucinated, and destructive AI-generated code from reaching production. It enforces safety across the entire development lifecycle — before execution, during development, before commit, during CI/CD, and before deployment.
CodeTrust is not a linter. It is not a formatter. It is a **governance enforcement platform** purpose-built for the era of AI-generated code, with four capabilities no existing tool provides.
---
## The Four Moats
### Moat 1: AI Governance Gateway
The Gateway intercepts AI agent actions **before execution** — not scanning files after the fact. Terminal commands, file writes, and package installs are validated against configurable policies in real-time.
76 interception rules across 11 categories: file destruction, code execution, privilege escalation, git operations, container escape, network exfiltration, secrets exposure, supply chain attacks, AI agent enforcement, resource abuse, and root-cause enforcement — plus content rules for file writes.
All rules are configurable. Any rule can be disabled per-project.
**Real proof:** During development, our own AI agent attempted to create a file using a heredoc pattern. The CodeTrust gateway blocked it in real-time — the product protected itself from its own builder.
### Moat 2: Hallucination Detection Engine
Every scan extracts imports from your source files and verifies them against **live package registries**. Hallucinated packages are flagged with exact file and line number.
```
$ codetrust scan app.py
🛡️ CodeTrust Scan
Files: 1 | Findings: 2
AI Drift Score: 87/100 (B)
🚫 BLOCK — must fix:
app.py:4 [import_not_found] Package 'flask_magic_utils' not found
on pypi — possible AI hallucination.
```
`flask_magic_utils` does not exist on PyPI. Most traditional tools do not verify imports against live registries at development time.
CodeTrust also includes static hallucination rules that detect fabricated methods, config options, CLI flags, API endpoints, environment variables, and placeholder URLs — without network access.
**Signature Validation** goes deeper: a curated database of 33 modules and 209 functions validates call signatures with min/max argument enforcement. When AI writes `os.path.join("a")` (too few args) or `hashlib.sha256("a", "b", "c")` (too many), CodeTrust catches it at scan time.
### Moat 3: Trust Score & Drift Tracking
A quantified safety metric that tracks your codebase over time. Not a snapshot — a trend.
- Baseline your project's safety score
- Track improvement or regression across commits
- Grade curve: A+ through F
- Fail CI when the score drops below your threshold
```
🛡️ CodeTrust Scan
Files: 47 | Findings: 3
AI Drift Score: 94/100 (A)
Trend: improving (+6 from baseline)
```
### Moat 4: Universal IDE Injection
Install once. CodeTrust injects its governance rules into the global configuration of every AI coding IDE on the machine — Claude Code, Cursor, Windsurf, and GitHub Copilot. Every new AI session starts rule-aware, with no manual configuration required.
AI agents that follow their system context — which the vast majority do — will proactively call CodeTrust validation tools. Sessions where AI ignores instructions are caught by Moat 1 (the pre-commit hook), the hard technical backstop that enforces regardless of model behaviour.
| IDE | What gets written |
|---|---|
| Claude Code | `~/.claude/CLAUDE.md` |
| Cursor | `~/.cursor/rules/codetrust.mdc` |
| Windsurf | `~/.codeium/windsurf/memories/global_rules.md` |
| GitHub Copilot | VS Code global `codeGeneration.instructions` |
- **Zero configuration** — governance activates on install, not on setup
- **Every IDE, globally** — rules are in place before the first keystroke in any workspace
- **Active monitoring** — if an IDE update overwrites the injected rules, or a new IDE is installed after CodeTrust, a warning notification appears immediately with a one-click re-inject action
- **Complete audit trail** — every gateway action, approved or blocked, written to the append-only audit log
- **Defense in depth** — instruction injection (proactive) + active monitoring (self-healing) + pre-commit hook (reactive) cover the full lifecycle
---
## Why CodeTrust Exists
AI writes code fast. But fast doesn't mean safe. **78% of developers** use AI coding assistants daily (2025). These tools produce failure modes that no existing tool detects:
| Failure Mode | What Happens | Who Catches It |
|---|---|---|
| **Hallucinated packages** | `pip install` fails — or worse: typosquatted malware installs | CodeTrust verifies imports against live registries |
| **Destructive agent commands** | `rm -rf /`, dynamic code execution, `curl\|sh` — data loss, RCE, supply chain compromise | CodeTrust Gateway intercepts before execution |
| **Ghost Docker images** | AI references images that don't exist — build breaks at 2AM | CodeTrust validates images against Docker Hub |
| **Invisible code drift** | AI code quality degrades gradually — no one measures it | CodeTrust tracks trust score over time |
### What existing tools miss
| Tool | What it does | What it doesn't do |
|---|---|---|
| **SonarQube** | 5,000+ quality rules | Does not intercept AI agents, verify imports, or track trust scores |
| **Snyk** | CVEs in known packages | Does not intercept AI agents, detect hallucinated packages, or track trust scores |
| **Semgrep** | Cross-file dataflow analysis | Does not intercept AI agents, verify imports against registries, or track trust scores |
| **FOSSA / WhiteSource** | License compliance scanning | Does not intercept AI agents, detect hallucinated packages, or scan code quality |
| **Ruff / ESLint** | Code style, formatting | Does not intercept AI agents, verify imports, or track trust scores |
CodeTrust combines pre-execution interception, live registry verification, quantified safety tracking, CVE scanning, license compliance, cross-file analysis, auto-fix PRs, and team management — all in one platform, all free.
---
## 10 Enforcement Layers
CodeTrust scans code across 10 layers covering static analysis, root cause analysis, SQL safety, AST structural analysis, container hardening, infrastructure-as-code, framework-specific rules (React, Kubernetes, CI/CD), live import verification, Docker image verification, and the real-time AI governance gateway.
**204 scan rules + 76 gateway rules = 280 total.** Every rule produces a BLOCK, WARN, or INFO verdict.
---
## Enforcement Model
CodeTrust enforces policies when integrated via MCP, pre-commit hooks, or CI/CD pipelines. Enforcement strength depends on integration point.
**Strong enforcement:**
| Integration | Guarantee |
|---|---|
| **Pre-commit hook** | Prevents unsafe commits — commit rejected until fixed |
| **CI/CD (GitHub Action)** | Prevents unsafe merges — PR fails required status check |
| **Gateway via MCP** | Prevents unsafe agent actions — command intercepted before execution |
**Advisory enforcement:**
| Integration | Behavior |
|---|---|
| **VS Code Extension** | Inline diagnostics — informs, does not block |
| **CLI scan** | Exit code 1 on BLOCK findings — enforcement depends on pipeline gating |
---
## When to Use CodeTrust
- **AI-assisted development** — Claude Code, GitHub Copilot, Cursor, or any AI coding assistant
- **CI/CD pipelines** requiring governance enforcement before merge
- **Preventing hallucinated dependencies** from reaching production
- **Blocking destructive agent actions** before they execute
- **Enforcing DevOps and infrastructure safety policies** across teams
- **Tracking code safety trends** to catch regression early
---
## Performance
| Operation | Typical Time |
|-----------|:------------:|
| Static scan (per file) | < 200ms |
| Gateway validation (per command) | < 5ms |
| Deep scan (typical project) | < 2s |
| Import verification (cached) | < 50ms |
| Production runtime overhead | Zero |
CodeTrust runs at development time only. Zero runtime overhead in production.
---
## Quick Start
```bash
pip install codetrust
cd your-project
codetrust init
codetrust scan .
```
`codetrust init` sets up enforcement layers in your project: pre-commit hook, GitHub Action, AI assistant rules, governance config, and audit directory.
---
## Five Ways In
| Surface | Install | What You Get |
|---------|---------|--------------|
| **CLI** | `pip install codetrust` | Full scan from terminal with exit code enforcement |
| **VS Code** | Install from Marketplace | Scan on save, inline diagnostics, AI governance |
| **GitHub Action** | `uses: S-Borna/codetrust@v2.7.0` | PR checks with SARIF upload to Security tab |
| **MCP Server** | 21 tools for AI agents | Claude Code / Cursor / Windsurf get real-time safety feedback |
| **REST API** | 45 endpoints with rate limiting | Integrate into any pipeline or platform |
---
## CLI Usage
```bash
codetrust scan app.py # Scan a file
codetrust scan src/ # Scan a directory
codetrust scan . --sarif # SARIF output for CI
codetrust scan . --json # JSON output
codetrust scan . --no-verify-imports # Skip registry checks (offline)
codetrust scan . --changed-only --dedupe # Reduce noise in large repos
codetrust scan . --suppress-lint-noise # Optional suppression for lint-heavy output
codetrust status # Check enforcement status
codetrust doctor # Diagnose installation
codetrust pr-risk # Repo-aware PR risk summary (git diff aware)
codetrust trust-diff # Compare trust score: HEAD vs working tree
codetrust trend record # Record a local snapshot
codetrust trend show # Show recorded snapshots
codetrust policy wizard # Generate governance policy presets + TOML autocomplete
codetrust vuln # Scan dependencies for known CVEs (OSV database)
codetrust license # Check dependency license compliance
codetrust fix # Apply auto-fix recipes
codetrust fix --pr # Apply fixes and open a GitHub PR
codetrust governance --status # Governance overview
codetrust governance --mode audit # Switch to audit mode
codetrust audit --hours 24 # Review recent actions
```
---
## VS Code Extension
```bash
code --install-extension SaidBorna.codetrust
```
- Scans on save (configurable)
- Scan on type (opt-in, debounced) using the embedded offline scanner
- Inline diagnostics with severity levels
- Works fully offline — all scan rules embedded
- "Scan Workspace" — up to 500 files with progress UI
- Profile create/apply commands for quick setup
- Quick Fixes for common findings
- Health Check command for connectivity and config sanity
- AI governance controls built in
- Deep scan mode for full analysis
| Setting | Default | Description |
|---------|---------|-------------|
| `codetrust.apiUrl` | `https://api.codetrust.ai` | API server URL |
| `codetrust.apiKey` | `""` | Deprecated: stored in VS Code Secret Storage. Use Guided Onboarding to set it |
| `codetrust.scanOnSave` | `true` | Auto-scan on save |
| `codetrust.scanOnType` | `false` | Scan while typing (embedded offline scanner) |
| `codetrust.scanOnTypeDebounceMs` | `600` | Debounce delay for scan while typing |
| `codetrust.severityThreshold` | `INFO` | Minimum severity to show |
| `codetrust.enabledLanguages` | `[...]` | Languages to scan |
| `codetrust.scanType` | `static` | `static` or `deep` |
| `codetrust.verifyImportsOnSave` | `false` | Verify imports on save (network) |
| `codetrust.timeout` | `15000` | Request timeout in milliseconds |
| `codetrust.governance.enabled` | `true` | Enable AI governance |
| `codetrust.governance.mode` | `enforce` | `enforce` / `audit` / `off` |
Self-hosting: set `codetrust.apiUrl` to your own API base URL.
---
## GitHub Action
Add CodeTrust to any GitHub Actions workflow. BLOCK findings fail the status check. Hallucinated packages appear as inline PR annotations via SARIF.
<details>
<summary><strong>Complete workflow file</strong> — copy to <code>.github/workflows/codetrust.yml</code></summary>
```yaml
name: CodeTrust Scan
on:
pull_request:
push:
branches: [main]
permissions:
actions: read
contents: read
pull-requests: write
security-events: write
jobs:
codetrust:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: S-Borna/codetrust@v2.7.0
with:
fail-on: block # block | warn | info
scan-type: static # static | deep
sarif: true # upload to GitHub Security tab
# api-key: ${{ secrets.CODETRUST_API_KEY }} # optional
- uses: github/codeql-action/upload-sarif@v4
if: always()
with:
sarif_file: codetrust-results.sarif
```
</details>
**Inputs:**
| Input | Default | Description |
|-------|---------|-------------|
| `fail-on` | `block` | Minimum severity to fail the check |
| `scan-type` | `static` | `static` or `deep` |
| `sarif` | `true` | Generate SARIF for GitHub Security tab |
| `api-key` | — | Optional API key (from `secrets.CODETRUST_API_KEY`) |
---
## MCP Servers
CodeTrust ships two MCP servers for different purposes:
| Server | Command | Purpose | Tools |
|--------|---------|---------|-------|
| **Scan Server** | `codetrust-mcp` | Code scanning, import verification, SARIF export | 10 tools |
| **Gateway Server** | `codetrust-gateway-mcp` | Real-time AI action interception — blocks destructive commands before execution | 11 tools |
**Use both for full coverage.** The Scan Server gives AI agents code analysis capabilities. The Gateway Server intercepts and validates every command, file write, and package install the agent attempts.
### Scan Server tools
`codetrust_static_scan` · `codetrust_ast_scan` · `codetrust_deep_scan` · `codetrust_verify_imports` · `codetrust_verify_dockerfile` · `codetrust_sandbox_run` · `codetrust_sarif_export` · `codetrust_pre_action` · `codetrust_post_action` · `codetrust_list_rules`
### Gateway Server tools
`codetrust_validate_command` · `codetrust_validate_file_write` · `codetrust_validate_file_delete` · `codetrust_validate_package` · `codetrust_governance_status` · `codetrust_audit_history` · `codetrust_list_gateway_rules` · `codetrust_run_in_terminal` · `codetrust_create_file` · `codetrust_replace_string_in_file` · `codetrust_edit_notebook`
### Setup: Claude Desktop / Claude Code
Add to `~/.claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"codetrust": {
"command": "codetrust-mcp"
},
"codetrust-gateway": {
"command": "codetrust-gateway-mcp"
}
}
}
```
### Setup: Cursor
Add to `.cursor/mcp.json` in your project root:
```json
{
"mcpServers": {
"codetrust": {
"command": "codetrust-mcp"
},
"codetrust-gateway": {
"command": "codetrust-gateway-mcp"
}
}
}
```
### Setup: Windsurf
Add to `~/.codeium/windsurf/mcp_config.json`:
```json
{
"mcpServers": {
"codetrust": {
"command": "codetrust-mcp"
},
"codetrust-gateway": {
"command": "codetrust-gateway-mcp"
}
}
}
```
Requires `pip install codetrust` so that `codetrust-mcp` and `codetrust-gateway-mcp` are on your PATH.
---
## Supported Languages
| Language | Static | AST | Import Verification |
|----------|:------:|:---:|:-------------------:|
| Python | ✅ | ✅ | ✅ (PyPI) |
| JavaScript / TypeScript | ✅ | ✅ | ✅ (npm) |
| Go | ✅ | ✅ | ✅ (Go proxy) |
| Rust | ✅ | ✅ | ✅ (crates.io) |
| Java | ✅ | ✅ | ✅ (Maven) |
| C# | ✅ | ✅ | ✅ (NuGet) |
| Ruby | ✅ | ✅ | ✅ (RubyGems) |
| PHP | ✅ | ✅ | ✅ (Packagist) |
| C / C++ | ✅ | ✅ | — |
| Shell / Bash | ✅ | — | — |
| Terraform / HCL | ✅ | — | — |
| HTML | ✅ | — | — |
| SQL | ✅ | — | — |
| Dockerfile | ✅ | — | ✅ (Docker Hub) |
| YAML / Kubernetes | ✅ | — | — |
| PowerShell | ✅ | — | — |
---
## Configuration
CodeTrust is configured via `.codetrust.toml` in your project root, or `[tool.codetrust]` in `pyproject.toml`. Run `codetrust init` to generate a starter config.
<details>
<summary><strong>Full configuration reference</strong></summary>
```toml
# .codetrust.toml
[codetrust]
exclude_paths = ["migrations/", "vendor/", "node_modules/"]
ignore_rules = [] # e.g. ["eval_exec", "hardcoded_secret"]
[codetrust.governance]
enabled = true
mode = "enforce" # enforce | audit | off
[codetrust.governance.terminal]
block_heredoc = true # Block heredoc (<<EOF) patterns
block_eval = true # Block eval/exec calls
block_sudo = false # Block sudo commands
block_rm_rf = true # Block rm -rf /
block_curl_pipe_sh = true # Block curl|sh piping
block_git_push = true # Block git push from AI agents
block_chmod_777 = true # Block chmod 777
[codetrust.governance.files]
protected_paths = ["LICENSE", ".env", ".env.production"]
scan_before_write = true # Scan file content before allowing write
[codetrust.governance.packages]
verify_before_install = true # Registry lookup before pip/npm install
block_suspicious_packages = true # Block known typosquat patterns
[codetrust.governance.audit]
enabled = true
path = ".codetrust/audit.jsonl" # Append-only audit log
retention_days = 90
[codetrust.governance.webhooks]
# url = "https://hooks.slack.com/services/T.../B.../xxx"
# provider = "slack" # slack | teams | generic
# on_block = true
# on_warn = false
```
</details>
**Override any setting via environment variable:** `CODETRUST_GOVERNANCE_MODE=audit`
### Custom Rules
Add your own governance rules without modifying CodeTrust source. Define them in `.codetrust/custom_rules.yaml` or under `[codetrust.governance.custom_rules]` in `.codetrust.toml`.
<details>
<summary><strong>YAML example — <code>.codetrust/custom_rules.yaml</code></strong></summary>
```yaml
terminal_rules:
- id: no_docker_privileged
pattern: "docker\\s+run\\s+--privileged"
message: "Privileged Docker containers are not allowed"
suggestion: "Remove --privileged flag"
severity: BLOCK
- id: no_force_push
pattern: "git\\s+push\\s+--force"
message: "Force push is blocked by policy"
suggestion: "Use --force-with-lease instead"
severity: BLOCK
content_rules:
- id: no_console_log
pattern: "console\\.log\\("
message: "console.log found in production code"
suggestion: "Use a structured logger"
severity: WARN
```
</details>
**Rules:**
- `id` — unique identifier (auto-prefixed with `custom_` at runtime)
- `pattern` — Python regex matched against terminal commands or file content
- `message` — shown when the rule triggers
- `suggestion` — recommended fix (optional)
- `severity` — `BLOCK` (hard stop) or `WARN` (flag only)
---
## Security & Compliance
| Property | Description |
|----------|-------------|
| **Audit trail** | Append-only, immutable log of all governance actions |
| **Agent identification** | Auto-detects Claude, Copilot, Cursor, Windsurf, GitHub Actions |
| **Secret scanning** | Catches hardcoded secrets, private keys, and credentials |
| **Rate limiting** | Per-key and IP-based with sliding windows |
| **SSO** | Azure AD, Okta, Auth0, Google, Keycloak |
| **GDPR** | Data export (Art. 15) and right to erasure (Art. 17) |
| **SIEM export** | CEF, LEEF, Syslog, ECS JSON |
| **SBOM** | CycloneDX generation (planned) |
| **Signed releases** | Sigstore signing (planned) |
---
## Enterprise Services
Five capabilities that match or exceed paid features from Snyk, SonarQube, Semgrep, FOSSA, and WhiteSource — included free.
### CVE / Vulnerability Scanning
Checks dependencies against the [OSV](https://osv.dev) vulnerability database (Google). Supports PyPI, npm, crates.io, Go, Maven, NuGet, RubyGems, Packagist.
```bash
codetrust vuln # Scan from requirements.txt / package.json
codetrust vuln --language python # Explicit language
codetrust vuln --json # Machine-readable output
```
**API:** `POST /v1/vuln/scan` — batch check up to 200 packages in a single request.
### License Compliance
Extracts licenses from package registries (PyPI, npm, RubyGems, Packagist, Maven, NuGet). Classifies as permissive, weak copyleft, strong copyleft, or network copyleft (AGPL). Flags compliance risks.
```bash
codetrust license # Check from dependency files
codetrust license --json # Machine-readable output
```
**API:** `POST /v1/license/scan`
### Cross-File Import Analysis
Builds the import dependency graph for a project. Detects circular dependencies, orphan files, hub files, and propagates findings across import chains.
**API:** `POST /v1/scan/cross-file`
### Auto-Fix PRs
Applies safe, deterministic fix recipes (print→logging, bare except, hardcoded secrets→env vars) and optionally opens a GitHub PR with the fixes.
```bash
codetrust fix # Apply fixes locally
codetrust fix --pr # Create a GitHub PR with fixes
```
**API:** `POST /v1/fix/apply` — supports optional PR creation via GitHub API.
### Team Management & RBAC
Organizations, team memberships, and role-based access control. Enforce org-wide policies: maximum severity gates, vulnerability thresholds, blocked licenses.
| Role | Permissions |
|------|------------|
| **Owner** | Full control, billing, transfer ownership, delete org |
| **Admin** | Manage members, edit policies, view billing |
| **Member** | Run scans, create API keys |
| **Viewer** | View scans and policies |
**API:** 10 endpoints under `/v1/orgs/*` — create/list/delete orgs, manage members, enforce policies.
---
## Distribution
| Channel | Install |
|---------|---------|
| **PyPI** | `pip install codetrust` |
| **VS Code Marketplace** | `code --install-extension SaidBorna.codetrust` |
| **GitHub Action** | `uses: S-Borna/codetrust@v2.7.0` |
| **Cloud API** | Available at `api.codetrust.ai` |
| **MCP Server** | Included in the package |
| **Website** | [codetrust.ai](https://codetrust.ai) |
---
## Development
```bash
pip install -e ".[dev]"
pytest # 1898 tests
ruff check . # zero warnings
```
All counts in this README are generated from source and validated in CI.
---
## License
Proprietary — Copyright (c) 2026 Said Borna. All rights reserved. See [LICENSE](LICENSE).
| text/markdown | null | Said Borna <contact@codetrust.ai> | null | null | null | ai-safety, claude-code, code-quality, cursor, devops, governance, hallucination, kubernetes, mcp, react, sarif, security, verification | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: Other/Proprietary License",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Quality Assurance"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"alembic>=1.13.0",
"asyncpg>=0.29.0",
"fastapi>=0.115.0",
"httpx>=0.27.0",
"mcp[cli]>=1.0.0",
"psycopg2-binary>=2.9.0",
"pydantic-settings>=2.0.0",
"pydantic>=2.0.0",
"pyjwt>=2.8.0",
"redis[hiredis]>=5.0.0",
"sqlalchemy[asyncio]>=2.0.0",
"stripe>=7.0.0",
"structlog>=24.0.0",
"tree-sitter-c-sharp>=0.23.0",
"tree-sitter-cpp>=0.23.0",
"tree-sitter-go>=0.23.0",
"tree-sitter-java>=0.23.0",
"tree-sitter-javascript>=0.23.0",
"tree-sitter-php>=0.23.0",
"tree-sitter-python>=0.23.0",
"tree-sitter-ruby>=0.23.0",
"tree-sitter-rust>=0.23.0",
"tree-sitter-typescript>=0.23.0",
"tree-sitter>=0.23.0",
"uvicorn[standard]>=0.30.0",
"aiosqlite>=0.20.0; extra == \"dev\"",
"fakeredis[json]>=2.20.0; extra == \"dev\"",
"httpx[cli]>=0.27.0; extra == \"dev\"",
"pytest-asyncio>=0.24.0; extra == \"dev\"",
"pytest-cov>=5.0.0; extra == \"dev\"",
"pytest-httpx>=0.30.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\"",
"ruff>=0.5.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://codetrust.ai",
"Documentation, https://codetrust.ai",
"Support, https://codetrust.ai"
] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T17:27:25.949068 | codetrust-2.7.0.tar.gz | 19,924 | fc/ac/0bb94e2dfcc4d2394c189085eadf5931aaf2a44f4378a1d2a6aa06e1b0ff/codetrust-2.7.0.tar.gz | source | sdist | null | false | bccc7ae6ae49f6bcec313ee3efd03cfa | 5357e0e85c9411c14173555c5ac7e586750eda9b10788dacd036c6531ca10e99 | fcac0bb94e2dfcc4d2394c189085eadf5931aaf2a44f4378a1d2a6aa06e1b0ff | LicenseRef-Proprietary | [
"LICENSE"
] | 199 |
2.4 | metacontroller-pytorch | 0.2.22 | Transformer Metacontroller | <img src="./fig1.png" width="400px"></img>
## metacontroller
Implementation of the MetaController proposed in [Emergent temporal abstractions in autoregressive models enable hierarchical reinforcement learning](https://arxiv.org/abs/2512.20605), from the Paradigms of Intelligence team at Google
## Install
```shell
$ pip install metacontroller-pytorch
```
## Appreciation
- [Pranoy](https://github.com/pranoyr) for submitting a pull request for fixing the previous latent action not being included in the inputs to the switching unit
- [Diego Calanzone](https://github.com/ddidacus) for proposing testing on BabyAI gridworld task, and submitting the [pull request](https://github.com/lucidrains/metacontroller/pull/3) for behavior cloning and discovery phase training for it!
- [Andrew Song](https://github.com/andrewsonga) for ongoing implementation of the PinPad environment!
- [Diego Calanzone](https://github.com/ddidacus) for his experimental acumen, bringing the project to an initial [working state](https://github.com/lucidrains/metacontroller/pull/13) for the BabyAI environment!
- [Andrew Song](https://github.com/andrewsonga) for implementing linear probing and fixing an issue with the action space
- [Andrew Song](https://github.com/andrewsonga) for identifying a critical issue with past action embed handling and detaching gradients of target states
- [Diego Calanzone](https://github.com/ddidacus) for identifying inconsistencies in the MetaController
## Usage
```python
import torch
from metacontroller import Transformer, MetaController
# 1. initialize model
model = Transformer(
dim = 512,
action_embed_readout = dict(num_discrete = 4),
state_embed_readout = dict(num_continuous = 384),
lower_body = dict(depth = 2),
upper_body = dict(depth = 2)
)
state = torch.randn(2, 128, 384)
actions = torch.randint(0, 4, (2, 128))
# 2. behavioral cloning (BC)
state_loss, action_loss = model(state, actions)
(state_loss + action_loss).backward()
# 3. discovery phase
meta_controller = MetaController(
dim_model = 512,
dim_meta_controller = 256,
dim_latent = 128
)
state_pred_loss, action_recon_loss, kl_loss, aux_ratio_loss = model(
state,
actions,
meta_controller = meta_controller,
discovery_phase = True
)
# they did not use state pred loss in the paper (weight set to 0, but available)
# the ratio loss from h-net paper is also available, but optional (set ratio_loss_weight > 0)
(action_recon_loss + kl_loss * 0.1).backward()
# 4. internal rl phase (GRPO)
# ... collect trajectories ...
logits, cache = model(
one_state,
past_action_id,
meta_controller = meta_controller,
return_cache = True
)
meta_output = cache.prev_hiddens.meta_controller
old_log_probs = meta_controller.log_prob(meta_output.action_dist, meta_output.actions)
# ... calculate advantages ...
# for GRPO, the inputs to policy loss should be of shape (batch, seq, dim_latent)
# where dim_latent is the dimension of the latent action space
loss = meta_controller.policy_loss(
group_states,
group_old_log_probs,
group_latent_actions,
group_advantages,
group_switch_betas
)
loss.backward()
```
Or using [evolutionary strategies](https://arxiv.org/abs/2511.16652) for the last portion
```python
# 5. evolve (ES over GRPO)
model.meta_controller = meta_controller
def environment_callable(model):
# return a fitness score
return 1.0
model.evolve(
num_generations = 10,
environment = environment_callable
)
```
## Contributing
To install the dependencies for testing, run
```shell
$ uv sync --extra test
```
To run the tests with pytest, run
```shell
$ uv run pytest
```
## Citations
```bibtex
@misc{kobayashi2025emergenttemporalabstractionsautoregressive,
title = {Emergent temporal abstractions in autoregressive models enable hierarchical reinforcement learning},
author = {Seijin Kobayashi and Yanick Schimpf and Maximilian Schlegel and Angelika Steger and Maciej Wolczyk and Johannes von Oswald and Nino Scherrer and Kaitlin Maile and Guillaume Lajoie and Blake A. Richards and Rif A. Saurous and James Manyika and Blaise Agüera y Arcas and Alexander Meulemans and João Sacramento},
year = {2025},
eprint = {2512.20605},
archivePrefix = {arXiv},
primaryClass = {cs.LG},
url = {https://arxiv.org/abs/2512.20605},
}
```
```bibtex
@article{Wagenmaker2025SteeringYD,
title = {Steering Your Diffusion Policy with Latent Space Reinforcement Learning},
author = {Andrew Wagenmaker and Mitsuhiko Nakamoto and Yunchu Zhang and Seohong Park and Waleed Yagoub and Anusha Nagabandi and Abhishek Gupta and Sergey Levine},
journal = {ArXiv},
year = {2025},
volume = {abs/2506.15799},
url = {https://api.semanticscholar.org/CorpusID:279464702}
}
```
```bibtex
@misc{hwang2025dynamicchunkingendtoendhierarchical,
title = {Dynamic Chunking for End-to-End Hierarchical Sequence Modeling},
author = {Sukjun Hwang and Brandon Wang and Albert Gu},
year = {2025},
eprint = {2507.07955},
archivePrefix = {arXiv},
primaryClass = {cs.LG},
url = {https://arxiv.org/abs/2507.07955},
}
```
```bibtex
@misc{fleuret2025freetransformer,
title = {The Free Transformer},
author = {François Fleuret},
year = {2025},
eprint = {2510.17558},
archivePrefix = {arXiv},
primaryClass = {cs.LG},
url = {https://arxiv.org/abs/2510.17558},
}
```
```bibtex
@misc{hafner2025trainingagentsinsidescalable,
title = {Training Agents Inside of Scalable World Models},
author = {Danijar Hafner and Wilson Yan and Timothy Lillicrap},
year = {2025},
eprint = {2509.24527},
archivePrefix = {arXiv},
primaryClass = {cs.AI},
url = {https://arxiv.org/abs/2509.24527},
}
```
*Life can only be understood backwards; but it must be lived forwards* - Søren Kierkegaard
| text/markdown | null | Phil Wang <lucidrains@gmail.com> | null | null | MIT License Copyright (c) 2025 Phil Wang 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. | artificial intelligence, deep learning, hierarchical reinforcement learning, latent steering | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.9",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"assoc-scan>=0.0.3",
"discrete-continuous-embed-readout>=0.1.12",
"einops>=0.8.1",
"einx>=0.3.0",
"jax",
"jaxlib",
"loguru",
"memmap-replay-buffer>=0.0.25",
"torch-einops-utils>=0.0.30",
"torch>=2.5",
"vector-quantize-pytorch>=1.27.20",
"x-evolution>=0.1.23",
"x-mlps-pytorch",
"x-transformers>=2.16.0",
"pytest; extra == \"test\""
] | [] | [] | [] | [
"Homepage, https://pypi.org/project/metacontroller/",
"Repository, https://github.com/lucidrains/metacontroller"
] | uv/0.8.17 | 2026-02-20T17:27:24.711408 | metacontroller_pytorch-0.2.22.tar.gz | 24,042 | ee/49/ced915c1b48675f851b895aad1f77ae44dc2bb86665a1895ccb2368560e8/metacontroller_pytorch-0.2.22.tar.gz | source | sdist | null | false | 9bcdda49be53694bb461ee2ec772eb57 | c275bb87c87bcba5a138dd9318bfce0ecf9de3853f4a18b7e2e6fa848df077f6 | ee49ced915c1b48675f851b895aad1f77ae44dc2bb86665a1895ccb2368560e8 | null | [
"LICENSE"
] | 209 |
2.4 | laakhay-core | 0.1.1 | Core types and models for the Laakhay ecosystem | # Laakhay Core
`laakhay-core` is the high-performance, zero-dependency bedrock of the Laakhay ecosystem. It provides the source of truth for all domain models, identity grammars, and primitive types.
## 🏗 Philosophy: The "Thin Core"
This library follows a strict separation of **Data** and **Behavior**.
- **Schema Authority**: Defines *what* a Bar or Position is.
- **Identity Authority**: Centralizes URM (Universal Representation Mapping).
- **Stability First**: Zero runtime dependencies to prevent version drift.
[Read more about our Philosophy](docs/philosophy.md)
---
## 🛠 Features
- **Standardized Identity**: [URM System](docs/urm.md) for exchange-agnostic instrument resolution.
- **Atomic Models**: Efficient [OHLCV (Bar), Orders, and Positions](docs/models.md).
- **Semantic Components**: Type-safe `BaseAsset`, `QuoteAsset`, and `InstrumentExpiry`.
- **Memory Efficient**: Uses `__slots__` and `frozen` dataclasses for high-throughput trading.
- **Python 3.9+**: Built for modern Python environments.
---
## 🚀 Quick Start
### Installation
`laakhay-core` is meant to be used as a backend library:
```bash
pip install laakhay-core
```
### Basic Usage
```python
from laakhay.core import Bar, Timeframe, AssetSpec, parse_urm_id
# 1. Create a high-performance Bar
bar = Bar(ts=1708453200, open="52000", high="52500", low="51800", close="52100", volume="150")
# 2. Work with Identities (Stocks or Crypto)
# Equity URM
aapl = parse_urm_id("urm://nasdaq:aapl:equity")
# Crypto spot URM
btc = parse_urm_id("urm://binance:btc/usdt:spot")
# 3. Handle Metadata
aapl_meta = AssetSpec(symbol="AAPL", currency="USD", precision=2)
```
## 📖 Documentation
- [Universal Representation Mapping (URM)](docs/urm.md)
- [Core Models & Specifications](docs/models.md)
- [Architectural Philosophy](docs/philosophy.md)
## 🧪 Development
```bash
make test # Run all unit tests
make lint # Check formatting and types
```
| text/markdown | null | Laakhay Corporation <laakhay.corp@gmail.com> | null | null | MIT | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"build>=1.0.0; extra == \"dev\"",
"pyright>=1.1.406; extra == \"dev\"",
"pytest-cov>=4.1.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"twine>=5.0.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://laakhay.com",
"Repository, https://github.com/laakhay/core",
"Issues, https://github.com/laakhay/core/issues"
] | uv/0.9.4 | 2026-02-20T17:27:17.666175 | laakhay_core-0.1.1.tar.gz | 15,693 | 43/b2/c6ea5660f0a34a6ca49c2f688c673fdb5ca898872d8ce429d8106569328d/laakhay_core-0.1.1.tar.gz | source | sdist | null | false | 830e4bdc27d05627c74d0dee2dbb6ca6 | d3af0aeba3fcc5e9116c238f3f19940d5e2047576a138ca625b7b9cc5cb5ffc1 | 43b2c6ea5660f0a34a6ca49c2f688c673fdb5ca898872d8ce429d8106569328d | null | [
"LICENSE"
] | 215 |
2.4 | jb-drf-auth | 0.1.11 | Reusable auth + profiles foundations for Django/DRF projects | # jb-drf-auth
[](https://pypi.org/project/jb-drf-auth/)
[](https://test.pypi.org/project/jb-drf-auth/)
Reusable authentication module for Django + Django REST Framework.
PyPI: https://pypi.org/project/jb-drf-auth/
TestPyPI: https://test.pypi.org/project/jb-drf-auth/
`jb-drf-auth` is a reusable foundation for authentication flows across projects, including:
- User/profile base models (extensible)
- OTP flows (email/SMS)
- Login, registration, password reset, email confirmation
- Multi-profile support
- Provider-based SMS/email architecture
- Configurable behavior via Django settings
## Installation
```bash
pip install jb-drf-auth
```
Add `jb_drf_auth` and `rest_framework` to `INSTALLED_APPS`.
## Documentation
- Main docs index: `docs/README.md`
- Getting started and configuration: `docs/getting-started.md`
- API contract (endpoint by endpoint): `docs/API_CONTRACT.md`
- Social authentication guide: `docs/social-auth.md`
- Migration guide: `docs/migration.md`
- i18n integration guide: `docs/i18n.md`
- Release guide: `docs/release.md`
- Roadmap: `roadmap.md`
## Quick Start
1. Configure concrete models in your project (`User`, `Profile`, `Device`, `OtpCode`, logs).
2. Configure `JB_DRF_AUTH` settings (minimal real-world example):
```python
JB_DRF_AUTH = {
"PROFILE_MODEL": "authentication.Profile",
"DEVICE_MODEL": "authentication.Device",
"OTP_MODEL": "authentication.OtpCode",
"SMS_LOG_MODEL": "authentication.SmsLog",
"EMAIL_LOG_MODEL": "authentication.EmailLog",
"FRONTEND_URL": env("JB_DRF_AUTH_FRONTEND_URL", default="http://localhost:3000"),
"DEFAULT_FROM_EMAIL": "no-reply@your-domain.com",
"AUTHENTICATION_TYPE": "both", # "email", "username", "both"
"AUTH_SINGLE_SESSION_ON_MOBILE": env.bool(
"AUTH_SINGLE_SESSION_ON_MOBILE", default=False
),
"MOBILE_NOTIFICATION_TOKEN_REQUIRED": env.bool(
"MOBILE_NOTIFICATION_TOKEN_REQUIRED", default=False
),
"ADMIN_BOOTSTRAP_TOKEN": env("JB_DRF_AUTH_ADMIN_BOOTSTRAP_TOKEN", default="super-secret-token"),
"PROFILE_PICTURE_UPLOAD_TO": "uploads/users/profile-pictures",
"PERSON_ID_DOCUMENTS_UPLOAD_TO": "uploads/people/id-documents",
"PROFILE_ROLE_CHOICES": (
("PATIENT", "Patient"),
("DOCTOR", "Doctor"),
("ADMIN", "Admin"),
),
"DEFAULT_PROFILE_ROLE": "PATIENT",
"SMS_SENDER_ID": "YourBrand",
"SMS_OTP_MESSAGE": "Tu codigo para acceder a Mentalysis es {code}. Expira en {minutes} minutos.",
}
```
If you use `env(...)`/`env.bool(...)`, ensure `environ.Env()` is configured in your settings module.
Recommended convention: use `JB_DRF_AUTH_` prefix for library-related env vars.
3. Mount URLs:
```python
from django.urls import include, path
urlpatterns = [
path("auth/", include("jb_drf_auth.urls")),
]
```
4. Run migrations in the integrator project.
For complete setup examples (including full `JB_DRF_AUTH` dict), see `docs/getting-started.md`.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"Django>=5.0",
"djangorestframework>=3.15",
"djangorestframework-simplejwt>=5.3",
"PyJWT<3,>=2.7",
"drf-extra-fields>=3.7",
"django-filter>=24.2",
"django-safedelete<2.0,>=1.4",
"argon2-cffi~=25.1.0",
"bcrypt~=4.0.1",
"boto3>=1.34",
"Pillow>=10.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:26:51.932240 | jb_drf_auth-0.1.11.tar.gz | 46,489 | e1/4e/d3474db40c6923dad696ac1e18e6e9184d7cf134f88430cb392b0b83289d/jb_drf_auth-0.1.11.tar.gz | source | sdist | null | false | c1690a3f461e218fc99a376d37066e05 | b4f0fca76c05c69eba80af011032bd1c6a6c84c810b7cc3b44ea4821fcf50cad | e14ed3474db40c6923dad696ac1e18e6e9184d7cf134f88430cb392b0b83289d | null | [
"LICENSE"
] | 209 |
2.4 | ytstudio-cli | 0.1.1 | CLI tool to manage and analyze your YouTube channel from the terminal | # YT Studio CLI
[](https://github.com/jdwit/ytstudio/actions/workflows/ci.yml)
[](https://pypi.org/project/ytstudio-cli/)
[](https://pypi.org/project/ytstudio-cli/)
[](https://opensource.org/licenses/MIT)
Manage and analyze your YouTube channel from the terminal. Ideal for automation and AI workflows.
## Motivation
I built this because I needed to bulk update video titles for a YouTube channel I manage with 300+
videos. YouTube Studio does not support bulk search-replace operations, which made it a tedious
manual process. This tool uses the YouTube Data API to perform bulk operations on video metadata.
Furthermore, it provides features for analytics and comment moderation, all accesible from the
command line.
## Installation
I recommend the excellent [uv](https://uv.io/) tool for installation:
```bash
uv tool install ytstudio-cli
```
## Setup
1. Create a [Google Cloud project](https://console.cloud.google.com/)
1. Enable **YouTube Data API v3** and **YouTube Analytics API**
1. Configure OAuth consent screen:
- Go to **APIs & Services** → **OAuth consent screen**
- Select **External** and create
- Fill in app name and your email
- Skip scopes, then add yourself as a test user
- Leave the app in "Testing" mode (no verification needed)
1. Create OAuth credentials:
- Go to **APIs & Services** → **Credentials**
- Click **Create Credentials** → **OAuth client ID**how
- Select **Desktop app** as application type
- Download the JSON file
1. Configure ytstudio:
```bash
ytstudio init --client-secrets path/to/client_secret_<id>.json
ytstudio login
```
Credentials stored in `~/.config/ytstudio/`.
## API quota
The YouTube Data API enforces a default quota of 10_000 units per project per day. Most read
operations (listing videos, comments, channel info) cost 1 unit, while write operations like
updating video metadata or moderating comments cost 50 units each. Bulk updates can consume quota
quickly. When exceeded, the API returns a 403 error; quota resets at midnight Pacific Time.
You can request a quota increase via **IAM & Admin** → **Quotas** in the
[Google Cloud Console](https://console.cloud.google.com/). See the
[official quota documentation](https://developers.google.com/youtube/v3/getting-started#quota) for
full details.
## Disclaimer
This project is not affiliated with or endorsed by Google. YouTube and YouTube Studio are trademarks
of Google. All channel data is accessed exclusively through the official
[YouTube Data API](https://developers.google.com/youtube/v3) and
[YouTube Analytics API](https://developers.google.com/youtube/analytics).
| text/markdown | null | Jelmer de Wit <1598297+jdwit@users.noreply.github.com> | null | null | MIT | analytics, cli, creator, video, youtube, youtube-studio | [
"Development Status :: 3 - Alpha",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"google-api-python-client>=2.0.0",
"google-auth-oauthlib>=1.0.0",
"google-auth>=2.0.0",
"packaging>=21.0",
"rich>=13.0.0",
"typer>=0.9.0"
] | [] | [] | [] | [
"Homepage, https://github.com/jdwit/ytstudio-cli",
"Repository, https://github.com/jdwit/ytstudio-cli"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:26:24.410289 | ytstudio_cli-0.1.1.tar.gz | 705,898 | 88/bf/cd081f969e936aaa1e6f05675cfef2f1ad99d78a779298457d8f4be4c978/ytstudio_cli-0.1.1.tar.gz | source | sdist | null | false | 682362dd4c0479a2caf523375c689028 | 1ab0c655ffb8c234f5644544dd1f4ce21907adbb87bff77c21f7ffaeabbf9c4b | 88bfcd081f969e936aaa1e6f05675cfef2f1ad99d78a779298457d8f4be4c978 | null | [
"LICENSE"
] | 186 |
2.4 | laakhay-data | 0.2.7 | Data infrastructure built with ♥︎ by Laakhay | # Laakhay Data
**Beta-stage async-first cryptocurrency market data aggregation library.**
> ⚠️ **Beta Software**: This library is in active development. Use with caution in production environments. APIs may change between versions.
Unified API for multi-exchange market data with support for **Binance**, **Bybit**, **OKX**, **Hyperliquid**, **Kraken**, and **Coinbase**. Modular provider architecture with REST/WebSocket abstraction, type-safe Pydantic models, and high-level streaming feeds.
## Installation
```bash
pip install laakhay-data
```
## Quick Start
```python
import asyncio
from laakhay.data.core import DataAPI, MarketType, Timeframe
async def main():
async with DataAPI() as api:
# Fetch OHLCV data
ohlcv = await api.fetch_ohlcv(
symbol="BTCUSDT",
timeframe=Timeframe.H1,
exchange="binance",
market_type=MarketType.SPOT,
limit=100,
)
print(f"Fetched {len(ohlcv)} bars")
# Stream real-time trades
async for trade in api.stream_trades(
symbol="BTCUSDT",
exchange="binance",
market_type=MarketType.SPOT,
):
print(f"{trade.symbol}: ${trade.price} ({trade.side})")
break
asyncio.run(main())
```
## Supported Exchanges
| Exchange | Spot | Futures | REST | WebSocket |
|----------|------|---------|------|-----------|
| **Binance** | ✅ | ✅ | ✅ | ✅ |
| **Bybit** | ✅ | ✅ | ✅ | ✅ |
| **OKX** | ✅ | ✅ | ✅ | ✅ |
| **Hyperliquid** | ❌ | ✅ | ✅ | ✅ |
| **Kraken** | ✅ | ✅ | ✅ | ✅ |
| **Coinbase** | ✅ | ❌ | ✅ | ✅ |
## Data Types
| Type | REST | WebSocket | Markets |
|------|------|-----------|---------|
| **OHLCV Bars** | ✅ | ✅ | Spot, Futures |
| **Order Book** | ✅ | ✅ | Spot, Futures |
| **Trades** | ✅ | ✅ | Spot, Futures |
| **Liquidations** | ❌ | ✅ | Futures |
| **Open Interest** | ✅ | ✅ | Futures |
| **Funding Rates** | ✅ | ✅ | Futures |
| **Mark Price** | ❌ | ✅ | Futures |
| **Symbol Metadata** | ✅ | ❌ | Spot, Futures |
## Key Features
- **Unified DataAPI**: Single interface across all exchanges
- **Universal Symbol Mapping (URM)**: Use any symbol format
- **Capability Discovery**: Check feature support before requests
- **Type-Safe Models**: Immutable Pydantic v2 models
- **High-Level Feeds**: OHLCV, liquidation, and open interest feeds
- **Stream Relay**: Forward streams to Redis, Kafka, or custom sinks
## Documentation
Comprehensive documentation is available in the [`docs/`](./docs/) directory:
- **[Getting Started](./docs/guides/getting-started.md)** - Quick start guide
- **[Examples](./docs/examples/)** - Code examples for common use cases
- **[API Reference](./docs/api-reference/)** - Complete API documentation
- **[Architecture](./docs/architecture/)** - System architecture and design decisions
- **[Guides](./docs/guides/)** - Usage guides and best practices
See the [Documentation Index](./docs/INDEX.md) for complete navigation.
## Requirements
- Python 3.12+
- `pydantic>=2.0`
- `aiohttp>=3.8`
- `websockets>=10`
## License
MIT License - see [LICENSE](LICENSE)
---
Built by [Laakhay Corporation](https://laakhay.com)
| text/markdown | null | Laakhay Corporation <laakhay.corp@gmail.com> | null | null | null | finance, market-data, trading | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Intended Audience :: Financial and Insurance Industry",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Office/Business :: Financial"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"aiohttp>=3.8",
"laakhay-core",
"pydantic>=2.0",
"websockets>=10",
"build>=1.0; extra == \"dev\"",
"mypy>=1.0.0; extra == \"dev\"",
"pytest-asyncio>=0.24.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.4; extra == \"dev\"",
"twine>=5.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://laakhay.com"
] | uv/0.9.4 | 2026-02-20T17:26:21.738447 | laakhay_data-0.2.7.tar.gz | 187,790 | 14/d4/bebfb2f562ad34dc627f61864803ad911652defcd5d60b875414177652f0/laakhay_data-0.2.7.tar.gz | source | sdist | null | false | e42314bdb764be058c8d78f747273655 | 4dd5bc2677332f7cc5417e9f42c8f62e26b1bc90e783cc4027a94c271a35f187 | 14d4bebfb2f562ad34dc627f61864803ad911652defcd5d60b875414177652f0 | MIT | [
"LICENSE"
] | 215 |
2.4 | dsperse | 3.3.0 | Distributed zkML Toolkit | # DSperse: Distributed zkML
[](https://github.com/inference-labs-inc/dsperse)
[](https://discord.gg/GBxBCWJs)
[](https://t.me/inference_labs)
[](https://x.com/inference_labs)
[](https://inferencelabs.com)
[](http://arxiv.org/abs/2508.06972)
DSperse is a toolkit for slicing, analyzing, and running neural network models. It currently supports ONNX models, allowing you to break down complex models into smaller segments for detailed analysis, optimization, and verification.
## Features
- **Model Slicing**: Split neural network models into individual layers or custom segments
- **ONNX Support**: Slice and orchestrate ONNX models
- **Layered Inference**: Run inference on sliced models, chaining the output of each segment
- **Zero-Knowledge Proofs**: Generate proofs for model execution via multiple backends:
- **JSTprove**: Fast, efficient ZK proof generation (default, with fallback)
- **EZKL**: Alternative ZK proof backend
- **Flexible Backend Selection**: Choose backends per-layer or use automatic fallback
- **Visualization**: Analyze model structure and performance
## Documentation
For more detailed information about the project, please refer to the following documentation:
- [Overview](docs/overview.md): A high-level overview of the project, its goals, and features
- [Architecture](docs/arc42.md): Up-to-date architecture summary (arc42-style) reflecting the current CLI and ONNX-only support
- [JSTprove Backend](docs/JSTPROVE_BACKEND.md): Detailed guide on JSTprove integration, backend selection, and usage examples
## CLI shorthands and aliases
Commands (subcommands):
- slice (alias: s)
- compile (alias: c)
- run (alias: r)
- prove (alias: p)
- verify (alias: v)
- full-run (alias: fr)
Common short flags:
- Model path: -m, --mp, --model-dir, --model-path
- Slices path/dir: -s, --sd, --slices, --slices-dir, --slices-directory, --slices-path (compile uses --slices-path; run uses --slices-dir)
- Input file: -i, --if, --input, --input-file
- Output file: -o, --output-file
- Layers: -l, --layers (compile, full-run)
- Run directory: --rd, --run-dir (prove, verify)
- Save analysis (slice only): -S, --save, --save-file
Examples:
```bash
# Slice (short form of command and flags)
dsperse s -m models/net -o models/net/slices -S
# Compile selected layers with calibration input
dsperse c -s models/net/slices -i models/net/input.json -l 0-2
# Run inference over slices with input and output paths (default backend behavior)
dsperse r -s models/net/slices -i models/net/input.json -o models/net/output.json
# Run inference forcing a backend when slices were compiled with multiple backends
# Use -b jstprove | ezkl | onnx (onnx skips circuit backends entirely)
dsperse r -s models/net/slices -i models/net/input.json -b jstprove
# Prove and verify a specific run
dsperse p --rd models/net/run/run_YYYYMMDD_HHMMSS
dsperse v --rd models/net/run/run_YYYYMMDD_HHMMSS
# Full pipeline (alias fr)
dsperse fr -m models/net -i models/net/input.json
```
## Backend selection
### Runtime backend flag (Runner)
You can select which backend to use at runtime when a slice was compiled with multiple circuit backends.
- CLI:
```bash
dsperse run -p models/net/slices -i models/net/input.json -b jstprove # or -b ezkl | -b onnx
```
- Python:
```text
from dsperse.src.run.runner import Runner
Runner().run(input_json_path="models/net/input.json", slice_path="models/net/slices", backend="ezkl")
```
Behavior rules:
- If a slice has both JSTprove and EZKL compiled, the selected backend is used for that slice.
- If a slice has only one circuit backend compiled, the flag is ignored for that slice (unless you choose `onnx`, which skips circuit backends and uses pure ONNX).
- If the selected backend fails on a slice that has multiple compiled backends, the runner falls back to the other compiled backend, then to ONNX.
Run results record which backend generated the witness per slice in `run/run_YYYYMMDD_HHMMSS/run_results.json`.
### Compile-time layer/backend selection
You can control which slices to compile and which backend(s) to use per slice using the `--layers/-l` argument along with the compiler's backend selection:
- Plain layer list (compile those indices with default fallback behavior):
```bash
dsperse compile -s models/net/slices -l 0,2,3-4
```
- Per-layer backend specification with groups separated by `;` and `index_or_range:backend` pairs:
```bash
dsperse compile -s models/net/slices --backend "2:jstprove;3-4:ezkl"
```
- Mixed with default groups (compile with both backends) by using a bare group without `:`:
```bash
# slice 0 -> default (both backends)
# slice 2 -> jstprove only
# slices 3-4 -> ezkl only
dsperse compile -s models/net/slices --backend "0;2:jstprove;3-4:ezkl"
```
Notes:
- Bare groups like `"0"` or `"0,5-6"` mean “default behavior (compile both backends)”.
- Unspecified slices are skipped during compilation and will run with ONNX at runtime.
### Prove and Verify alignment with witness backend
The prover and verifier automatically use the backend that produced the witness for each slice:
- JSTprove slices use the JSTprove circuit and the binary witness produced at runtime.
- EZKL slices use the EZKL compiled circuit, `pk.key` (prove) and `vk.key` (verify), and `settings.json` when available.
Results are merged into `run_results.json` with per-slice `proof_execution` and `verification_execution` entries and counters by backend.
## Installation
### Install from PyPI
The simplest way to install DSperse is via PyPI:
```bash
# Using pip
pip install dsperse
# Using uv (recommended)
uv tool install dsperse
```
When installed via PyPI, all dependencies are automatically installed when you run a command for the first time, eliminating any manual setup.
### Install from source
Preferred: one-step installer script
- Unix/macOS:
- Make sure you have Python 3.9+ available (and optionally a virtualenv activated).
- From the repo root:
```bash
./install.sh
```
- The script will:
- Install the DSperse CLI in editable mode so the dsperse command is available
- Install EZKL (prompting for cargo or pip method if needed)
- Check EZKL SRS files (~/.ezkl/srs). It will offer to download them interactively (downloads can take a while) because having them locally speeds up circuitization/proving.
Non-interactive/CI-friendly:
```bash
./install.sh -n
```
Manual install
If you prefer to install manually or are on Windows:
1) Create and activate a virtual environment (optional but recommended)
```bash
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
```
2) Install the DSperse CLI
```bash
pip install -e .
```
This exposes the dsperse command.
3) Install ZK Backend CLIs
**EZKL (optional, for EZKL backend):**
Recommended via cargo (requires Rust):
```bash
cargo install --locked ezkl
# Ensure $HOME/.cargo/bin is on your PATH
```
Alternative via pip:
```bash
pip install -U ezkl
# Note: CLI availability may vary by platform with the pip package. Verify with:
ezkl --version
```
**JSTprove (default backend):**
```bash
uv tool install jstprove
# or: pip install jstprove
```
Also requires Open MPI:
```bash
brew install open-mpi # macOS
# or apt-get install openmpi-bin libopenmpi-dev # Linux
```
Verify installation:
```bash
jst --help
```
4) (Optional but recommended) Download EZKL SRS files
SRS files are stored at ~/.ezkl/srs (kzg<N>.srs). They are needed for EZKL circuit setup/proving and downloading them ahead of time speeds things up.
Example manual command to fetch one size:
```bash
ezkl get-srs --logrows 20 --commitment kzg
```
Repeat for other logrows you need (commonly 2..21).
Note: JSTprove does not require SRS files.
Quickstart workflow
Below is an end-to-end walkthrough using the dsperse CLI. You can try it with the example model under models/net.
1) Slice the model
- You can provide either the model.onnx file or the model directory containing it.
Common examples:
```bash
dsperse slice --model-dir models/net
dsperse slice --model-dir models/net/model.onnx
```
Choose output directory (default: models/net/slices):
```bash
dsperse slice --model-dir models/net --output-dir models/net/slices
```
Optionally save analysis metadata to a file (use --save-file; if flag is given without value, default path is model_dir/analysis/model_metadata.json):
```bash
dsperse slice --model-dir models/net --save-file
dsperse slice --model-dir models/net --save-file models/net/analysis/model_metadata.json
```
What happens:
- Slices are written to models/net/slices/slice_<i>/payload/slice_<i>.onnx
- A model-level metadata.json is created at models/net/slices/metadata.json
### Metadata Files Behavior
DSperse creates different types of metadata files for different purposes:
**Operational Metadata** (`metadata.json`):
- **Location**: Always created in the output directory (e.g., `models/net/slices/metadata.json`)
- **Purpose**: Contains segment information, paths, and parameters needed for circuitization and proving
- **Created**: Automatically during slicing
- **Used by**: compile, prove, verify commands
**Analysis Metadata** (`model_metadata.json`):
- **Location**: Created in `model_dir/analysis/` when using `--save-file` flag
- **Purpose**: Detailed node-by-node analysis information for debugging and inspection
- **Created**: Only when `--save-file` flag is used
- **Used by**: Developers and analysts for model inspection
**Important Notes:**
- These are **two different files** serving different purposes
- The operational metadata is essential for dsperse to function
- The analysis metadata is optional and primarily for debugging
- Both files contain similar top-level information but different levels of detail
- **This behavior is intended** but can be confusing due to similar names and purposes
2) Compile with ZK Backends (JSTprove or EZKL)
- Compile either the whole model.onnx or the sliced segments (recommended for incremental proofs):
**Default (Fallback Mode):**
```bash
dsperse compile --slices-path models/net/slices
```
- Tries JSTprove first
- Falls back to EZKL if JSTprove fails
- Falls back to ONNX (skip ZK compilation) if both fail
**Single Backend:**
```bash
dsperse compile --slices-path models/net/slices --backend jstprove
dsperse compile --slices-path models/net/slices --backend ezkl
```
**Per-Layer Backend Assignment:**
```bash
dsperse compile --slices-path models/net/slices --backend "0,2:jstprove;3-4:ezkl"
```
- Layer 0 and 2: Use JSTprove
- Layer 3 and 4: Use EZKL
- Unspecified layers use default backend
Optional calibration input to improve settings:
```bash
dsperse compile --slices-path models/net/slices --input-file models/net/input.json
```
Optional layer selection (sliced models only):
```bash
dsperse compile --slices-path models/net/slices --layers 2,3,4
dsperse compile --slices-path models/net/slices --layers 0-2
```
What happens:
- For each selected segment, the chosen backend compiles the circuit
- JSTprove: Circuit artifacts saved under `models/net/slices/slice_<i>/jstprove/`
- EZKL: Circuit artifacts saved under `models/net/slices/slice_<i>/ezkl/`
- Slices metadata is updated with compilation info per segment
For more details on backend selection and JSTprove integration, see [JSTprove Backend Documentation](docs/JSTPROVE_BACKEND.md).
Note on missing slices:
- If you pass a model directory without slices metadata present, the CLI will prompt you to slice first.
3) Run inference
- Runs a chained execution over the slices using ZK backends where available and falling back to ONNX per-segment on failure.
Common examples:
```bash
dsperse run --slices-dir models/net # points to model dir (auto-detects slices)
dsperse run --slices-dir models/net/slices # or point directly to slices
```
You will be prompted for an input file if not provided (default: model_dir/input.json).
To save the final output:
```bash
dsperse run --slices-dir models/net/slices --input-file models/net/input.json --output-file models/net/output.json
```
What happens:
- A run metadata file is auto-generated at models/net/run/metadata.json if missing
- A timestamped run directory is created: models/net/run/run_YYYYMMDD_HHMMSS/
- Segment-by-segment inputs/outputs are saved under that run directory
- A run_results.json is written summarizing the chain execution
4) Generate proofs
- Proves the segments that successfully produced witnesses in the selected run.
Typical usage (new positional-args form):
```bash
dsperse prove models/net/run/run_YYYYMMDD_HHMMSS models/net/slices
# data_path can also be a single slice_* dir, a .dslice, or a .dsperse
# To write proofs under a custom root:
dsperse prove models/net/run/run_YYYYMMDD_HHMMSS models/net/slices --proof-output /tmp/my_proofs
```
Legacy flags are still accepted for backward compatibility (will prompt for selection):
```bash
dsperse prove --run-dir models/net/run
```
Optionally save the updated run results to a separate file:
```bash
dsperse prove models/net/run/run_YYYYMMDD_HHMMSS models/net/slices --output-file models/net/proof_results.json
```
What happens:
- For each segment with a successful witness, the CLI generates proofs
- Proof files are stored under the specific run's segment folder
- The run_results.json is updated with proof_execution details
5) Verify proofs
- Verifies the proofs generated in step 4 against the stored verification keys and settings.
Typical usage (new positional-args form):
```bash
dsperse verify models/net/run/run_YYYYMMDD_HHMMSS models/net/slices
# data_path can also be a single slice_* dir, a .dslice, or a .dsperse
```
Legacy flags are still accepted for backward compatibility (will prompt for selection):
```bash
dsperse verify --run-dir models/net/run
```
Optionally save verification results to a separate file:
```bash
dsperse verify models/net/run/run_YYYYMMDD_HHMMSS models/net/slices --output-file models/net/verification_results.json
```
What happens:
- For each segment with a proof, the CLI verifies the proof
- The run_results.json is updated with verification_execution details
- A summary of verified segments is printed
Tips and troubleshooting
- Backend CLI not found:
- JSTprove: Ensure `jst` is on your PATH (`uv tool install jstprove` or `pip install jstprove`) and Open MPI is installed
- EZKL: Ensure `ezkl` is on your PATH. If installed via cargo, add $HOME/.cargo/bin to PATH.
- SRS files missing/slow downloads (EZKL only):
- You can skip downloads during install and fetch later with `ezkl get-srs --logrows <N> --commitment kzg`
- Compile says "slice first":
- Run dsperse slice --model-dir <model_dir> to produce slices and metadata.json
- Paths in saved JSON are absolute on your machine; sharing outputs across machines may require path adjustments.
Project structure (updated)
- src/
- slicer.py: orchestrator for slicing (uses OnnxSlicer)
- compiler.py: orchestrator for compilation (backend pipeline with fallback)
- runner.py: chained execution across segments (ZK backends or ONNX fallback)
- backends/
- onnx_models.py: ONNX inference utilities
- jstprove.py: JSTprove CLI bindings and circuitization pipeline
- ezkl.py: EZKL CLI bindings and circuitization pipeline
- cli/
- base.py: shared CLI helpers
- slice.py: slice command
- compile.py: compile command
- run.py: run command
- prove.py: prove command
- verify.py: verify command
- analyzers/: metadata generation for runs/slices
- utils/: common helpers
- main.py: CLI entry point (dsperse)
- install.sh: installer for CLI, EZKL, and optional SRS
Contributing
Contributions are welcome! Please feel free to open issues and PRs.
License
See the LICENSE file for details.
## End-to-end: full-run
Run the entire pipeline (slice → compile → run → prove → verify) with a single interactive command.
Usage:
```bash
# Kebab-case (preferred)
dsperse full-run --model-dir path/to/model_or_dir --input-file path/to/input.json
# Short alias also works
dsperse fr --model-dir path/to/model_or_dir --input-file path/to/input.json
```
Notes:
- You can pass a model directory that contains model.onnx or a direct path to model.onnx.
- The command is interactive; if an argument is missing, it will prompt you (consistent with other subcommands).
- Slices will be created under <model_dir>/slices unless you provide an existing one.
- Proofs and verification use the latest run under <model_dir>/run by default.
Optional flags:
- --slices-dir: Reuse a pre-existing slices directory to skip the slicing step.
- --layers: Restrict which layers to compile (same format as compile, e.g., "3, 20-22").
Examples:
```bash
# One-shot end-to-end on the sample model
cd src/models/net
# if you have an input.json in this directory
dsperse full-run --model-dir . --input-file ./input.json
# From repo root, specifying paths explicitly
dsperse full-run --model-dir src/models/resnet --input-file src/models/resnet/input.json
# Reuse pre-sliced directory and only compile select layers
dsperse full-run \
--model-dir src/models/net \
--slices-dir src/models/net/slices \
--input-file src/models/net/input.json \
--layers "1, 3-5"
```
## Slicing outputs and flags
By default, `dsperse slice` produces a single portable bundle named after your slices folder, e.g. `slices.dsperse`. When you pass `--output-dir models/net/slices`, the slicer stages files under `models/net/slices/` and then the converter creates `models/net/slices.dsperse` and cleans up the staging directory.
What the `.dsperse` contains:
- A top-level `metadata.json` describing the model and slices
- All per-slice `.dslice` archives (one per slice)
Choose the output format with `--output-type` (default: `dsperse`):
- `--output-type dsperse` (default): creates `models/net/slices.dsperse` and removes `models/net/slices/`
- `--output-type dslice`: creates `.dslice` files under `models/net/slices/` (and keeps `metadata.json`); removes intermediate `slice_#/` directories
- `--output-type dirs`: keeps raw `slice_#/` directories with `payload/` and per-slice `metadata.json`
Examples:
```bash
# Default: produce only slices.dsperse (staging dir cleaned up)
dsperse slice -m models/net/model.onnx -o models/net/slices
# Produce per-slice .dslice files in a directory (keeps metadata.json)
dsperse slice -m models/net/model.onnx -o models/net/slices --output-type dslice
# Keep unpacked slice_# directories
dsperse slice -m models/net/model.onnx -o models/net/slices --output-type dirs
```
Notes:
- The `.dsperse` bundle is a ZIP file; you can inspect it with any unzip tool.
- Each `.dslice` inside the bundle is also a ZIP with its own `metadata.json` and `payload/model.onnx`.
## Convert between formats
Use `dsperse slice convert` (or the top-level `dsperse convert`) to go back and forth between single-file bundles and directory layouts. The converter auto-detects the input type; you specify the target with `--to {dirs, dslice, dsperse}`.
Supported conversions:
- slices.dsperse -> directory (contains `*.dslice` + `metadata.json`; add `--expand-slices` to also create `slice_#/` folders)
- directory (with `slice_#/` or `*.dslice` + `metadata.json`) -> slices.dsperse
- slice_X.dslice -> directory (extracts to `slice_X/` with `payload/` and `metadata.json`)
- directory (a single `slice_X/` folder with `payload/` + `metadata.json`) -> slice_X.dslice
Usage examples:
```bash
# 1) Unpack a bundle next to the file (default: keeps .dslice files, does not expand slices)
dsperse slice convert -i models/net/slices.dsperse --to dirs
# 1b) Unpack and also expand each embedded .dslice into slice_# folders
dsperse slice convert -i models/net/slices.dsperse --to dirs --expand-slices
# 1c) Preserve the input bundle instead of deleting it after a successful conversion
dsperse slice convert -i models/net/slices.dsperse --to dirs --no-cleanup
# 2) Create a .dsperse from a directory
# If the input is a slices/ directory with slice_#/ subfolders, the converter will package and name it `<dirname>.dsperse`.
dsperse slice convert -i models/net/slices --to dsperse
# 3) Unpack a single .dslice to a directory
dsperse slice convert -i models/net/slices/slice_1.dslice --to dirs -o models/net/slices/slice_1
# 4) Create a .dslice from a slice directory (must contain metadata.json and payload/)
dsperse slice convert -i models/net/slices/slice_1 --to dslice -o models/net/slices/slice_1.dslice
```
Notes:
- If you omit --output, sensible defaults are chosen (e.g., extracting next to the input file with the same stem, or naming `<dirname>.dsperse`).
- Use `--cleanup/--no-cleanup` to control whether the source artifact is deleted after a successful conversion (default: cleanup enabled for `.dsperse` sources).
- The converter is the single source of truth for formats; CLI commands delegate to it to ensure consistent behavior and cleanup.
| text/markdown | null | Inference Labs <info@inferencelabs.com> | null | null | Copyright (c) 2025 Inference Labs Inc. Source Access Grant You may access, view, study, and modify the source code of this software. Redistribution Conditions You may redistribute this software in source or modified form provided that: a) You retain this license document and all copyright notices b) Any modified files carry prominent notices stating you changed them c) You do not misrepresent the origin of the software Usage Restriction NO USE RIGHTS ARE GRANTED BY THIS LICENSE. Any operational use including but not limited to: - Execution of the software - Integration with other systems - Deployment in any environment - Commercial or production utilization requires express written permission from the IP Owner. Intellectual Property Reservation All rights not expressly granted herein are reserved by the IP Owner. For usage permissions, contact: legal@inferencelabs.com Disclaimer THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. THE IP OWNER SHALL NOT BE LIABLE FOR ANY DAMAGES ARISING FROM ACCESS OR DISTRIBUTION. License Propagation Any distribution of this software or derivatives must be under this same license agreement. | null | [] | [] | null | null | ==3.13.* | [] | [] | [] | [
"torch==2.6.0",
"onnx==1.18.0",
"ezkl==22.2.1",
"numpy~=2.2.3",
"onnxruntime<2.0.0,>=1.21.0",
"colorama~=0.4.6",
"jstprove==2.7.0",
"pytest>=8.4.1; extra == \"dev\""
] | [] | [] | [] | [] | 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-20T17:25:21.198839 | dsperse-3.3.0-py3-none-any.whl | 1,970,522 | b6/fa/bfd78692b66ad26babda5ba0fc7ca107f95fe2f610bfd3d9bf0ab1389785/dsperse-3.3.0-py3-none-any.whl | py3 | bdist_wheel | null | false | 520495ec32b0956cc81ec9c28e272352 | 1898326b657a384af9b6e02836ce3d7f654547dc93bbb4bb9c91008450d96855 | b6fabfd78692b66ad26babda5ba0fc7ca107f95fe2f610bfd3d9bf0ab1389785 | null | [
"LICENSE"
] | 207 |
2.4 | ubcpdk | 3.3.3 | ubcpdk pdk | # ubcpdk (SiEPIC Ebeam PDK) 3.3.3
[](https://mybinder.org/v2/gh/gdsfactory/binder-sandbox/HEAD)
[](https://pypi.org/project/ubcpdk/)
[](https://choosealicense.com/licenses/mit/)
[](https://codecov.io/gh/gdsfactory/ubc)
[](https://github.com/psf/black)
SiEPIC Ebeam PDK adapted from [siepic Ebeam PDK](https://github.com/lukasc-ubc/SiEPIC_EBeam_PDK) for gdsfactory.
It provides a fully python driven flow alternative for the most advanced users taking the [edx course](https://www.edx.org/course/silicon-photonics-design-fabrication-and-data-ana)
## Installation
We recommend `uv`
```bash
# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh
```
```bash
# On Windows.
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```
### Installation for users
Use python 3.11, 3.12 or 3.13. We recommend [VSCode](https://code.visualstudio.com/) as an IDE.
```
uv pip install ubcpdk --upgrade
```
Then you need to restart Klayout to make sure the new technology installed appears.
### Installation for contributors
Then you can install with:
```bash
git clone https://github.com/gdsfactory/ubc.git
cd ubc
uv venv --python 3.12
uv sync --extra docs --extra dev
```
## Documentation
- [gdsfactory docs](https://gdsfactory.github.io/gdsfactory/)
- [UBCpdk docs](https://gdsfactory.github.io/ubc/) and [code](https://github.com/gdsfactory/ubc)
- [ubc1](https://github.com/gdsfactory/ubc1)
| text/markdown | null | gdsfactory <contact@gdsfactory.com> | null | null | null | python | [
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent"
] | [] | null | null | <3.13,>=3.12 | [] | [] | [] | [
"gdsfactory~=9.34.0",
"gplugins[sax,tidy3d]~=2.0.0",
"jsondiff",
"doroutes>=0.3.0",
"gdsfactoryplus==1.4.4",
"pytz",
"pytest; extra == \"dev\"",
"gdsfactoryplus; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest_regressions; extra == \"dev\"",
"pytest-github-actions-annotate-failures; extra == \"dev\"",
"pre-commit; extra == \"dev\"",
"autodoc_pydantic; extra == \"docs\"",
"jupytext; extra == \"docs\"",
"jupyter-book==1.0.3; extra == \"docs\"",
"gsim; extra == \"docs\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-20T17:25:01.980521 | ubcpdk-3.3.3.tar.gz | 12,698,003 | 53/31/22546c52620e97f53ce73166a379f2c8d1cb6b5745a43762203314657dbe/ubcpdk-3.3.3.tar.gz | source | sdist | null | false | 28c93285b773e3e7535d32684a3dcebc | c75792caee772cbb21370bfee5a27bf85d922b9a71890349a695559934168131 | 533122546c52620e97f53ce73166a379f2c8d1cb6b5745a43762203314657dbe | null | [
"LICENSE"
] | 250 |
2.4 | etl-utilities | 1.1.17 | This repository provides a collection of utility functions and classes for data cleaning, SQL query generation, and data analysis. The code is written in Python and uses libraries such as `pandas`, `numpy`, and `dateutil`. | # Project Documentation
## Table of Contents
1. [Overview](#overview)
2. [Classes](#classes)
- [Connector](#connector)
- [Loader](#loader)
- [MySqlLoader](#mysqlloader)
- [MsSqlLoader](#mssqlloader)
- [Parser](#parser)
- [Cleaner](#cleaner)
- [Creator](#creator)
- [Analyzer](#analyzer)
- [Validator](#validator)
- [MsSqlUpdater](#mssqlupdater)
3. [Logging](#logging)
4. [Additional Utilities](#additional-utilities)
## Overview
This project provides a comprehensive Data ETL \(Extract, Transform, Load\) and data manipulation framework using Python. It integrates with databases using SQLAlchemy and provides tools for data parsing, cleaning, loading, validating, and more. The project is structured with classes that encapsulate different functionalities.
## Classes
### Connector
The `Connector` class handles creating connections to various types of databases \(MSSQL, PostgreSQL, MySQL\) using SQLAlchemy. It provides static methods for obtaining both trusted and user connections.
**Key Methods:**
- `get_mssql_trusted_connection`
- `get_mssql_user_connection`
- `get_postgres_user_connection`
- `get_mysql_user_connection`
- Instance methods for returning database connections based on stored configuration.
### Loader
The `Loader` class is responsible for loading data from a Pandas DataFrame into a database. It manages the insertion process, ensuring data is inserted efficiently and effectively with the use of SQLAlchemy and custom logging.
### MySqlLoader
A slight extension of the `Loader` class specifically for MySQL databases. It provides overrides to manage MySQL-specific data types and query formatting.
### MsSqlLoader
A specialized loader for loading data into MSSQL databases with additional functionalities like fast insertions using bulk methods.
### Parser
The `Parser` class consists of a series of static methods dedicated to parsing various data types—boolean, float, date, and integer. These methods are essential for data type conversion and consistency across the application.
### Cleaner
The `Cleaner` class provides methods for sanitizing and formatting data in a DataFrame. It includes functions for setting column name casing conventions, cleaning various types of data, and preparing data for reliable analysis and insertion.
### Creator
This class deals with generating SQL `CREATE TABLE` statements for different databases like MSSQL and MariaDB. The query generation considers data types deduced from DataFrame content.
### Analyzer
The `Analyzer` class assesses DataFrame characteristics and helps identify unique columns, column pairs, empty columns, and more. It aids in generating metadata for data types, which is crucial for creating or validating schemas.
### Validator
The `Validator` class ensures DataFrame compatibility with the target database table structure by checking for extra columns, validating data types, and ensuring that no data truncation will occur during upload.
### MsSqlUpdater
A class designed for constructing SQL statements for operations like mergers, updates, inserts, and appends to manage data transitions between tables efficiently.
## Logging
The project uses a singleton `Logger` class with colored output format for console logging. This helps in debugging and understanding the flow by logging messages at various severity levels.
## Additional Utilities
- **Parsing and Cleaning Functions:** Utility functions for parsing and cleaning various data types.
- **Standardization:** A set of utility functions to standardize and clean DataFrame column names and content. | text/markdown | null | Jesse <magicjedi90@aim.com> | null | null | null | cleaning, database, dataframe, etl, etl-utilities, pandas, spark, utilities | [
"Development Status :: 4 - Beta",
"Programming Language :: Python",
"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 :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"numpy",
"pandas",
"polars",
"psycopg2-binary",
"pyspark",
"pytest>=8.3.5",
"python-dateutil",
"rich",
"sqlalchemy"
] | [] | [] | [] | [
"Documentation, https://github.com/magicjedi90/etl_utilities#readme",
"Issues, https://github.com/magicjedi90/etl_utilities/issues",
"Source, https://github.com/magicjedi90/etl_utilities"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:24:59.807275 | etl_utilities-1.1.17.tar.gz | 51,566 | a7/be/4aad850593e73f452a95cc3f0125c29352c0bc2036da68dc90a4c0a5f820/etl_utilities-1.1.17.tar.gz | source | sdist | null | false | 23f49b42044feda51a0d94c34aec68fe | edc89d7f178f4aa523d80b7dab2ac94842fa8a65df68cdab7ab6f1c79030dc79 | a7be4aad850593e73f452a95cc3f0125c29352c0bc2036da68dc90a4c0a5f820 | MIT | [
"LICENSE"
] | 200 |
2.4 | pickerxl | 0.2.4 | PickerXL is a large deep learning model to measure arrival times from noisy seismic signals. | # PickerXL
A large deep learning model to measure arrival times from noisy seismic signals. The model was developed by Chengping Chai, Derek Rose, Scott Stewart, Nathan Martindale, Mark Adams, Lisa Linville, Christopher Stanley, Anibely Torres Polanco and Philip Bingham.
## Introduction
This model is trained on STEAD (Mousavi et al., 2019) for Primary (P) and Secondary (S) wave arrival picking. The model was trained using earthquake data at local distances (0-350 km). The model uses 57s-long three-component seismograms sampled at 100 Hz as input. The output of the model are probability channels corresponding to P wave, S wave, and noise. These probabilities can be used to compute P- and S-wave arrival times.
## Installation
Creating a virtual environment is highly encouraged.
```
pip install pickerxl
```
To install only for CPU (e.g., macOS), you may use the following commands.
```
pip3 install torch torchvision torchaudio
pip3 install pickerxl
```
## Example Usage
```
from pickerxl.pickerxl import Picker
import numpy as np
import h5py
model = Picker()
fid = h5py.File("example_waveforms.h5", "r")
data_group = fid["data"]
example_data = []
true_p_index = []
true_s_index = []
for akey in data_group.keys():
dataset = data_group[akey]
example_data.append(dataset[...])
true_p_index.append(float(dataset.attrs["p_arrival_sample"]))
true_s_index.append(float(dataset.attrs["s_arrival_sample"]))
fid.close()
preds = model.predict_probability(example_data)
p_index, s_index = model.predict_arrivals(example_data)
print("True P-wave arrival index:", true_p_index)
print("Predicted P-wave arrival index:", p_index)
print("True S-wave arrival index:", true_s_index)
print("Predicted S-wave arrival index:", s_index)
```
## Test the Package
First, go to the top directory of the package. Then, using the following commands.
```
cd tests
python run_tests.py
```
## Known Limitations
* The model may have a less-than-optimal performance for earthquake data outside of a source-receiver distance range of 10–110 km and a magnitude range of 0–4.5 because of biases in the training data.
* The model may produce false detections when applied to continuous seismic data.
* The model may not perform well for earthquake data at larger distances or for non-earthquake sources.
## Reference
Chengping Chai, Derek Rose, Scott Stewart, Nathan Martindale, Mark Adams, Lisa Linville, Christopher Stanley, Anibely Torres Polanco, Philip Bingham; PickerXL, A Large Deep Learning Model to Measure Arrival Times from Noisy Seismic Signals. Seismological Research Letters 2025; 96 (4):2394-2404. doi: https://doi.org/10.1785/0220240353
## License
GNU GENERAL PUBLIC LICENSE version 3
## Credit
The architecture of the deep learning model was adapted from SeisBench (Woollam et al., 2022).
| text/markdown | null | "Chengping Chai, Derek Rose, Scott Stewart, Nathan Martindale, Mark Adams, Lisa Linville, Christopher Stanley, Anibely Torres Polanco and Philip Bingham" <chaic@ornl.gov> | null | null | null | null | [
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering",
"Programming Language :: Python :: 3",
"Operating System :: OS Independent"
] | [] | null | null | >=3.13 | [] | [] | [] | [
"torch>=2.3.0",
"numpy>=1.26.4",
"lightning>=2.2.4",
"h5py>=3.11.0",
"matplotlib>=3.8.0",
"flake8; extra == \"development\"",
"black; extra == \"development\"",
"pre-commit; extra == \"development\""
] | [] | [] | [] | [
"Homepage, https://github.com/ornl/picker-xl"
] | twine/6.2.0 CPython/3.13.12 | 2026-02-20T17:24:52.239090 | pickerxl-0.2.4.tar.gz | 16,377,719 | 6f/03/c095b52620a9f944480412a9a2c401bf447e849bbb193f8ce5d9e8cde9dc/pickerxl-0.2.4.tar.gz | source | sdist | null | false | eea96ec79d6116c893c567ba1ee72d48 | ee587e8c3646ca0dfcde55179ccf7c331055d9b27dafc0a16e19f28dca508d45 | 6f03c095b52620a9f944480412a9a2c401bf447e849bbb193f8ce5d9e8cde9dc | GPL-3.0-or-later | [
"LICENSE"
] | 208 |
2.4 | openlineage-sql | 1.44.1 | Python interface for the Rust OpenLineage lineage extraction library | # Python interface for the OpenLineage SQL Parser
Refer to the [GitHub for details](https://github.com/OpenLineage/OpenLineage). This package is not meant to be used alone by end-user.
| text/markdown; charset=UTF-8; variant=GFM | OpenLineage | null | null | null | null | openlineage | [
"Programming Language :: Rust",
"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 :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy"
] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:24:39.062684 | openlineage_sql-1.44.1.tar.gz | 40,389 | 7b/56/f9c300fa287ed6822dfc2e2bbbdefc9fd1bda2cdda6db5faf310fd0f17e7/openlineage_sql-1.44.1.tar.gz | source | sdist | null | false | fc4879dfd3659cc095d09b545cd0507b | 7676f99969796b062b5d5497d247916b2c74e3c25b9a37563a6d3d5f34a506e6 | 7b56f9c300fa287ed6822dfc2e2bbbdefc9fd1bda2cdda6db5faf310fd0f17e7 | null | [] | 175,962 |
2.3 | openlineage-python | 1.44.1 | OpenLineage Python Client | # OpenLineage Python Client
Python client for [OpenLineage](https://openlineage.io).
Refer to the [documentation](https://openlineage.io/docs/client/python) for details.
| text/markdown | OpenLineage | OpenLineage <info@openlineage.io> | null | null | null | openlineage | [
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3 :: Only",
"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"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"attrs>=20.0",
"python-dateutil>=2.8.2",
"pyyaml>=5.4",
"requests>=2.32.4",
"httpx>=0.27.0",
"packaging>=21.0",
"boto3>=1.34.134; extra == \"datazone\"",
"mypy; extra == \"dev\"",
"types-pyyaml; extra == \"dev\"",
"types-python-dateutil; extra == \"dev\"",
"types-requests; extra == \"dev\"",
"sphinx>=7.0; extra == \"docs\"",
"beautifulsoup4>=4.12.0; extra == \"docs\"",
"sphinx-autodoc-typehints>=2.0.0; extra == \"docs\"",
"pydata-sphinx-theme>=0.13; extra == \"docs\"",
"fsspec>=2023.1.0; extra == \"fsspec\"",
"google-cloud-datacatalog-lineage>=0.3.14; extra == \"gcplineage\"",
"ruff; extra == \"generator\"",
"click; extra == \"generator\"",
"datamodel-code-generator==0.33.0; extra == \"generator\"",
"confluent-kafka>=2.1.1; extra == \"kafka\"",
"aws-msk-iam-sasl-signer-python>=1.0.1; extra == \"msk-iam\"",
"confluent-kafka>=2.1.1; extra == \"msk-iam\"",
"covdefaults>=2.3; extra == \"test\"",
"pytest>=7.3.1; extra == \"test\"",
"pytest-cov>=4.1; extra == \"test\"",
"pytest-mock>=3.10; extra == \"test\"",
"pyyaml>=5.4; extra == \"test\"",
"uvicorn>=0.20.0; extra == \"test\"",
"fastapi>=0.100.0; extra == \"test\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:24:29.681091 | openlineage_python-1.44.1-py3-none-any.whl | 102,883 | 8f/5d/e398d28e8948e96fe869ba09415c60d0c10dd9653b8c376d93f1748f3b63/openlineage_python-1.44.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 5b4e41034980b28a6ed412c0bd45f9c8 | cc121f82cb15dcf5f2f1347bd30d4c83cae1d510809e6ccce111b98298271503 | 8f5de398d28e8948e96fe869ba09415c60d0c10dd9653b8c376d93f1748f3b63 | null | [] | 160,701 |
2.3 | openlineage-integration-common | 1.44.1 | OpenLineage common python library for integrations | # OpenLineage Integration Common
Common modules for OpenLineage integrations.
For setting up a development environment, see the [Python development setup guide](https://openlineage.io/docs/client/python/development/setup).
| text/markdown | OpenLineage | null | null | null | Apache-2.0 | openlineage | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software 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"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"attrs>=19.3.0",
"openlineage-python",
"openlineage-sql",
"pyyaml>=5.3.1",
"google-api-core>=1.26.3; extra == \"bigquery\"",
"google-auth>=1.30.0; extra == \"bigquery\"",
"google-cloud-bigquery<4.0.0,>=3; extra == \"bigquery\"",
"google-cloud-core>=1.6.0; extra == \"bigquery\"",
"google-crc32c>=1.1.2; extra == \"bigquery\"",
"google-api-core>=1.26.3; extra == \"dev\"",
"google-auth>=1.30.0; extra == \"dev\"",
"google-cloud-bigquery<4.0.0,>=3; extra == \"dev\"",
"google-cloud-core>=1.6.0; extra == \"dev\"",
"google-crc32c>=1.1.2; extra == \"dev\"",
"great-expectations>=1.0.0; extra == \"dev\"",
"sqlalchemy<2.0.0,>=1.3.24; extra == \"dev\"",
"boto3>=1.15.0; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest-mock; extra == \"dev\"",
"mock; extra == \"dev\"",
"pandas; extra == \"dev\"",
"jinja2; extra == \"dev\"",
"python-dateutil; extra == \"dev\"",
"mypy>=0.960; extra == \"dev\"",
"types-python-dateutil; extra == \"dev\"",
"types-pyyaml; extra == \"dev\"",
"ruff; extra == \"dev\"",
"google-api-core>=1.26.3; extra == \"dev-no-parser\"",
"google-auth>=1.30.0; extra == \"dev-no-parser\"",
"google-cloud-bigquery<4.0.0,>=3; extra == \"dev-no-parser\"",
"google-cloud-core>=1.6.0; extra == \"dev-no-parser\"",
"google-crc32c>=1.1.2; extra == \"dev-no-parser\"",
"great-expectations>=1.0.0; extra == \"dev-no-parser\"",
"sqlalchemy<2.0.0,>=1.3.24; extra == \"dev-no-parser\"",
"boto3>=1.15.0; extra == \"dev-no-parser\"",
"pytest; extra == \"dev-no-parser\"",
"pytest-cov; extra == \"dev-no-parser\"",
"pytest-mock; extra == \"dev-no-parser\"",
"mock; extra == \"dev-no-parser\"",
"pandas; extra == \"dev-no-parser\"",
"jinja2; extra == \"dev-no-parser\"",
"python-dateutil; extra == \"dev-no-parser\"",
"mypy>=0.960; extra == \"dev-no-parser\"",
"types-python-dateutil; extra == \"dev-no-parser\"",
"types-pyyaml; extra == \"dev-no-parser\"",
"great-expectations>=1.0.0; extra == \"great-expectations\"",
"sqlalchemy<2.0.0,>=1.3.24; extra == \"great-expectations\"",
"boto3>=1.15.0; extra == \"redshift\""
] | [] | [] | [] | [
"Homepage, https://openlineage.io/",
"Source, https://github.com/OpenLineage/OpenLineage/tree/main/integration/common"
] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:24:25.998521 | openlineage_integration_common-1.44.1-py3-none-any.whl | 57,640 | 16/a3/22483c3ba157a60dd7c58c4e325eaf92cb1c31f5b2b9faea8f65d1d711b6/openlineage_integration_common-1.44.1-py3-none-any.whl | py3 | bdist_wheel | null | false | d2479d4062f28e4e1fce1865a71dfeb7 | a8809b90e77bb97fbd99676c3a65ab661e7651c9d92ab406801398c1fe7ea53d | 16a322483c3ba157a60dd7c58c4e325eaf92cb1c31f5b2b9faea8f65d1d711b6 | null | [] | 106,144 |
2.3 | openlineage-dbt | 1.44.1 | OpenLineage integration with dbt | # OpenLineage dbt integration
Wrapper script for automatic metadata collection from dbt
## Features
**Metadata**
* Model run lifecycle
* Model inputs / outputs
## Requirements
- [Python >= 3.8](https://www.python.org/downloads)
- [dbt >= 0.20](https://www.getdbt.com/)
Right now, `openlineage-dbt` supports only these dbt adapters:
* `bigquery`
* `snowflake`
* `spark` (`thrift` and `odbc`, but not `local`)
* `redshift`
* `athena`
* `glue`
* `postgres`
* `clickhouse`
* `trino`
* `databricks`
* `sqlserver`
* `dremio`
* `duckdb`
## Installation
```bash
$ pip3 install openlineage-dbt
```
To install from source, run:
```bash
$ pip install .
```
## Configuration
### Transport
`openlineage-dbt` uses the OpenLineage Python client to push data to the OpenLineage backend, so any way of configuring Python client will work here as well:
```ini
OPENLINEAGE_URL=http://localhost:5000
OPENLINEAGE_API_KEY=abc
```
dbt integration-specific environment variables:
* `OPENLINEAGE_NAMESPACE` - set if you are using something other than the `default` namespace for job namespace.
### Logging
In addition to conventional logging approaches, the OpenLineage dbt wrapper script provides an alternative way of configuring its logging behavior. By setting the `OPENLINEAGE_DBT_LOGGING` environment variable, you can establish the logging level for the `openlineage.dbt` and its child modules.
You can also set log level of `dbtol` Python module but this is deprecated.
## Usage
To begin collecting dbt metadata with OpenLineage, replace `dbt run` with `dbt-ol run`.
Additional table and column level metadata will be available if `catalog.json`, a result of running `dbt docs generate`, will be found in the target directory.
If you need to send events without running the job you can use the command `dbt-ol send-events`, it will send the metadata of your last run without running the job.
## Development
For development setup instructions, see the [Python development setup guide](https://openlineage.io/docs/client/python/development/setup).
Quick start:
```bash
# From the repository root
$ make setup-dbt
# Or manually
$ cd integration/dbt
$ uv sync --extra dev
```
----
SPDX-License-Identifier: Apache-2.0\
Copyright 2018-2026 contributors to the OpenLineage project | text/markdown | OpenLineage | null | null | null | null | openlineage | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"tqdm>=4.62.0",
"openlineage-integration-common==1.44.1",
"dbt-core>=1.0.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest-xdist>=2.5.0; extra == \"dev\"",
"mock; extra == \"dev\"",
"ruff; extra == \"dev\"",
"mypy>=0.9.6; extra == \"dev\"",
"python-dateutil; extra == \"dev\"",
"requests>=2.25.0; extra == \"dev\"",
"docker>=6.0.0; extra == \"dev\"",
"mypy; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:24:25.180603 | openlineage_dbt-1.44.1-py3-none-any.whl | 6,309 | 42/a8/dbaf53a9d279da11d4fc6d1e7ad0887e7ba4cd46074f8ab70f28950de4b4/openlineage_dbt-1.44.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 43f430d379d182c44c1ddda4af6bec79 | 55d1075b54dbae5aa5382cc967fb4e18f54162978816375e8d02f04f0db715df | 42a8dbaf53a9d279da11d4fc6d1e7ad0887e7ba4cd46074f8ab70f28950de4b4 | null | [] | 247 |
2.4 | JSTprove | 2.7.0 | Zero-knowledge proofs of ML inference on ONNX models | ```
888888 .d8888b. 88888888888
"88b d88P Y88b 888
888 Y88b. 888
888 "Y888b. 888 88888b. 888d888 .d88b. 888 888 .d88b.
888 "Y88b. 888 888 "88b 888P" d88""88b 888 888 d8P Y8b
888 "888 888 888 888 888 888 888 Y88 88P 88888888
88P Y88b d88P 888 888 d88P 888 Y88..88P Y8bd8P Y8b.
888 "Y8888P" 888 88888P" 888 "Y88P" Y88P "Y8888
.d88P 888
.d88P" 888
888P" 888
```
---
# JSTprove
[](https://github.com/inference-labs-inc/JSTprove)
[](https://t.me/inference_labs)
[](https://x.com/inference_labs)
[](https://inferencelabs.com)
[](https://doi.org/10.48550/arXiv.2510.21024)
Zero-knowledge proofs of ML inference on **ONNX** models — powered by [Polyhedra Network’s **Expander**](https://github.com/PolyhedraZK/Expander) (GKR/sum-check prover) and [**Expander Compiler Collection (ECC)**](https://github.com/PolyhedraZK/ExpanderCompilerCollection).
* 🎯 **You bring ONNX** → we quantize, compile to a circuit, generate a witness, prove, and verify — via a simple CLI.
* ✅ Supported ops (current): **Conv2D**, **GEMM/MatMul (FC)**, **ReLU**, **MaxPool2D**, **Add**, **Mul**, **Sub**, **BatchNorm**.
* 🧰 CLI details: see **[docs/cli.md](docs/cli.md)**
👉 Just want to see it in action? Jump to [Quickstart (LeNet demo)](#quickstart-lenet-demo).<br>
👉 Curious about how it works under the hood? Check out the [white paper](https://doi.org/10.48550/arXiv.2510.21024).
---
## Table of Contents
<details>
<summary>Click to expand</summary>
- [What is JSTprove?](#what-is-jstprove)
- [High-level architecture](#high-level-architecture)
- [Design principles](#design-principles)
- [Installation](#installation)
- [0) Requirements](#0-requirements)
- [1) System packages](#1-system-packages)
- [2) Rust toolchain](#2-rust-toolchain)
- [3) Clone JSTprove & set up Python](#3-clone-jstprove--set-up-python)
- [4) Install & verify Expander (before building JSTprove)](#4-install--verify-expander-before-building-jstprove)
- [5) Build the JSTprove runner (optional; the CLI can build on demand)](#5-build-the-jstprove-runner-optional-the-cli-can-build-on-demand)
- [6) Try the CLI](#6-try-the-cli)
- [Quickstart (LeNet demo)](#quickstart-lenet-demo)
- [CLI reference](#cli-reference)
- [Troubleshooting](#troubleshooting)
- [Contributing](#contributing)
- [Disclaimer](#disclaimer)
- [Acknowledgments](#acknowledgments)
</details>
## What is JSTprove?
**JSTprove** is a [zkML](https://docs.inferencelabs.com/zk-ml) toolkit/CLI that produces [**zero-knowledge proofs**](https://docs.inferencelabs.com/resources/glossary#zero-knowledge-proof) **of AI** [**inference**](https://docs.inferencelabs.com/resources/glossary#inference).
You provide an **ONNX** model and inputs; JSTprove handles **quantization**, **circuit generation** (via ECC), **witness creation**, **proving** (via Expander), and **verification** — with explicit, user-controlled file paths.
### High-level architecture
* **Python pipeline:** Converts **ONNX → quantized ONNX**, prepares I/O, drives the Rust runner, exposes the **CLI**.
* **Rust crate:** `rust/jstprove_circuits` implements layer circuits (Conv2D, ReLU, MaxPool2D, GEMM/FC, BatchNorm) and a runner.
* **Circuit frontend:** [ECC](https://github.com/PolyhedraZK/ExpanderCompilerCollection) Rust API for arithmetic circuits.
* **Prover backend:** [Expander](https://github.com/PolyhedraZK/Expander) (GKR/sum-check prover/verification).
```
ONNX model ─► Quantizer (Py) ─► Circuit via ECC (Rust) ─► Witness (Rust) ─► Proof (Rust) ─► Verify (Rust)
```
### Design principles
- **User-friendly frontend to Expander:** A thin, practical, circuit-based layer that makes Expander/ECC easy to use from a simple CLI — no circuit classes, no path inference, predictable artifacts.
- **Explicit & reproducible:** You pass exact paths; we emit concrete artifacts (circuit, quantized ONNX, witness, proof). No hidden discovery or heuristics.
- **Clear separation:** Python orchestrates the pipeline and I/O; Rust implements the circuits and invokes Expander/ECC.
- **Quantization that's simple & faithful:** We scale tensors, **round to integers**, run the model, and (where needed) **rescale** outputs back. Scaling keeps arithmetic cheap while remaining close to the original FP behavior.
- **Small, fast circuits when possible:** Where safe, we fuse common patterns (e.g., **Linear + ReLU**, **Conv + ReLU**) into streamlined circuit fragments to reduce constraints.
- **Deterministic debugging:** We prefer loud failures and inspectable intermediates (e.g., `*_reshaped.json`) over implicit magic.
---
## Installation
### Installing from PyPI (Recommended)
#### Prerequisites
- **UV**: Fast Python package manager ([install UV](https://docs.astral.sh/uv/getting-started/installation/))
#### Install JSTprove
```bash
uv tool install JSTprove
```
#### Verify installation
```bash
jst --help
```
> **Prerequisite**: OpenMPI must be installed on the host:
> - **Ubuntu/Debian**: `sudo apt-get install -y openmpi-bin openmpi-common`
> - **Fedora/RHEL**: `sudo dnf install openmpi`
### Installing from GitHub Release
Download the appropriate wheel for your platform from the [latest release](https://github.com/Inference-Labs-Inc/jstprove/releases/latest):
- Linux: `JSTprove-*-manylinux_*.whl`
- macOS (Apple Silicon): `JSTprove-*-macosx_11_0_arm64.whl`
Then install:
```bash
uv tool install /path/to/JSTprove-*.whl
```
---
## Development Installation
<details>
<summary>Click to expand for development setup instructions</summary>
### 0) Requirements
- **Python**: >=3.12
- **UV**: Fast Python package manager ([install UV](https://docs.astral.sh/uv/getting-started/installation/))
> Note: UV will automatically install and manage the correct Python version for you.
> **Heads-up:** If you just installed `uv` and the command isn't found, **close and reopen your terminal** (or re-source your shell init file) so the `uv` shim is picked up on`PATH`.
### 1) System packages
> Run commands from the **repo root** so the runner binary path (e.g., `./target/release/onnx_generic_circuit`) resolves.
#### Ubuntu/Debian
```bash
sudo apt-get update && sudo apt-get install -y \
libopenmpi-dev openmpi-bin pkg-config libclang-dev clang
```
#### macOS
```bash
brew install open-mpi llvm
```
---
### 2) Rust toolchain
Install Rust via rustup (if you don't have it):
```bash
# macOS/Linux:
curl https://sh.rustup.rs -sSf | sh
# then restart your shell
```
Verify your install:
```bash
rustup --version
rustc --version
cargo --version
```
> This repo includes a `rust-toolchain.toml` that pins the required **nightly**.
> When you run `cargo` in this directory, rustup will automatically download/use
> the correct toolchain. You **do not** need to run `rustup override set nightly`.
(Optional) If you want to prefetch nightly ahead of time:
```bash
rustup toolchain install nightly
```
---
### 3) Clone JSTprove & set up Python
```bash
git clone https://github.com/inference-labs-inc/JSTprove.git
cd JSTprove
# Install dependencies with UV (automatically creates and manages virtual environment)
uv sync
```
> If `uv` was just installed, you may need to **restart your terminal** before running `uv sync`.
---
### 4) Install & verify **Expander** (before building JSTprove)
JSTprove relies on Polyhedra Network’s **Expander** (prover) and **Expander Compiler Collection (ECC)** crates.
For a clean environment, install Expander and run its self-checks first.
To keep paths simple (and to match our scripts), **clone Expander as a subfolder of this repo**:
```bash
# From the JSTprove repo root
git clone https://github.com/PolyhedraZK/Expander.git
cd Expander
git fetch
git checkout af1b7473bc858d250e481d6bb7db98a1ee6b7fc5
# Build (uses the toolchain you configured with rustup)
cargo build --release
```
**Verify Expander:** follow the “Correctness Test” (or equivalent) in the Expander README.
If you’re unsure, a quick smoke test is often:
```bash
cargo test --release
```
> Refer to the Expander README for the authoritative verification command(s), which may change over time.
> **Why inside the repo?** Our example commands and helper scripts assume `./Expander` as the manifest path. Keeping Expander elsewhere can lead to `manifest path 'Expander/Cargo.toml' does not exist` errors unless you always pass absolute paths.
*(You do **not** need to clone ECC separately unless you plan to override Cargo git sources; Cargo will fetch ECC automatically when building JSTprove.)*
---
### 5) Build the JSTprove runner (optional; the CLI can build on demand)
```bash
# Make sure you're back in the JSTprove repo root (not in Expander).
# If you just followed Step 3, run:
cd ../JSTprove
# Then build:
cargo build --release
```
> The CLI `compile` step will **(re)build** the runner automatically when needed, so this step is just a sanity check.
---
### 6) Install and try the CLI
**Option A: Install in virtual environment (for development)**
```bash
# Install as editable package in venv
uv pip install -e .
# Try the CLI (with venv activated)
jst --help
```
**Option B: Install globally (for regular use)**
```bash
# Install as global tool
uv tool install .
# Try the CLI (available globally)
jst --help
```
> ⏳ Note: The first time you run this command it may take a little while due to Python/Rust imports and initialization. This is normal—subsequent runs will be faster.
You can now follow the **Quickstart** commands (compile → witness → prove → verify).
</details>
---
## Quickstart (LeNet demo)
Demo paths:
* ONNX: `python/models/models_onnx/lenet.onnx`
* Input JSON: `python/models/inputs/lenet_input.json`
* Artifacts: `artifacts/lenet/*`
> ⏳ Note: The commands below may take a little longer _the first time_ they are run, as dependencies and binaries are initialized. After that, runtime reflects the actual computation (e.g., compiling circuits, generating witnesses, or proving), which can still be intensive depending on the model.
1. **Compile** → circuit + **quantized ONNX**
```bash
jst compile \
-m python/models/models_onnx/lenet.onnx \
-c artifacts/lenet/circuit.txt
```
2. **Witness** → reshape/scale inputs, run model, write witness + outputs
```bash
jst witness \
-c artifacts/lenet/circuit.txt \
-i python/models/inputs/lenet_input.json \
-o artifacts/lenet/output.json \
-w artifacts/lenet/witness.bin
```
3. **Prove** → witness → proof
```bash
jst prove \
-c artifacts/lenet/circuit.txt \
-w artifacts/lenet/witness.bin \
-p artifacts/lenet/proof.bin
```
4. **Verify** → check the proof (needs quantized ONNX for input shapes)
```bash
jst verify \
-c artifacts/lenet/circuit.txt \
-i python/models/inputs/lenet_input.json \
-o artifacts/lenet/output.json \
-w artifacts/lenet/witness.bin \
-p artifacts/lenet/proof.bin
```
If it prints **Verified**, you're done 🎉
---
## CLI reference
The CLI is intentionally minimal and **doesn't infer paths**.
See **[docs/cli.md](docs/cli.md)** for subcommands, flags, and examples.
---
## Troubleshooting
See **[docs/troubleshooting.md](docs/troubleshooting.md)**
---
## Contributing
See **[docs/CONTRIBUTING.md](docs/CONTRIBUTING.md)** for dev setup, pre-commit hooks, and PR guidelines.
---
## Disclaimer
**JSTProve** is **experimental and unaudited**. It is provided on an **open-source, “as-is” basis**, without any warranties or guarantees of fitness for a particular purpose.
Use of JSTProve in **production environments is strongly discouraged**. The codebase may contain bugs, vulnerabilities, or incomplete features that could lead to unexpected results, failures, or security risks.
By using, modifying, or distributing this software, you acknowledge that:
- It has not undergone a formal security review or audit.
- It may change substantially over time, including breaking changes.
- You assume full responsibility for any outcomes resulting from its use.
JSTProve is made available in the spirit of **research, experimentation, and community collaboration**. Contributions are welcome, but please proceed with caution and do not rely on this software for systems where correctness, reliability, or security are critical.
---
## Acknowledgments
We gratefully acknowledge [**Polyhedra Network**](https://polyhedra.network/) for:
* [**Expander**](https://github.com/PolyhedraZK/Expander) — the GKR/sumcheck proving system we build on.
* [**Expander Compiler Collection (ECC)**]() — the circuit frontend used to construct arithmetic circuits for ML layers.
| text/markdown | Inference Labs Inc | null | null | null | null | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"numpy==2.2.6",
"onnx<2.0,>=1.17.0",
"onnxruntime==1.21.0",
"onnxruntime_extensions==0.14.0",
"psutil==7.0.0",
"torch>=2.6.0",
"transformers>=4.53.0",
"zstandard>=0.25.0",
"msgpack>=1.0.0",
"filelock>=3.20.3",
"protobuf>=6.33.5",
"urllib3>=2.6.3"
] | [] | [] | [] | [] | 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-20T17:24:10.965561 | jstprove-2.7.0-py3-none-manylinux_2_28_x86_64.whl | 2,406,542 | 3a/d5/41a51b04119a7c09610120b008e2d98ca6d26a7d877ee728e05f4669a661/jstprove-2.7.0-py3-none-manylinux_2_28_x86_64.whl | py3 | bdist_wheel | null | false | e8d0f8bcda5780dc3e6365dc6b57c53f | c126ddc8d31311b90e4d98bbf285fab6f885db27ebbc8d7216cc577a417740b1 | 3ad541a51b04119a7c09610120b008e2d98ca6d26a7d877ee728e05f4669a661 | null | [
"LICENSE"
] | 0 |
2.4 | ai-content-autopilot | 1.0.2 | Python SDK for the Visibly Content Autopilot API - Pull API client, HMAC webhook verification, and Flask Blueprint. | # ai-content-autopilot
Python SDK for the **[Visibly Content Autopilot](https://www.antonioblago.com/content-autopilot)** API.
Visibly Content Autopilot is an AI-powered content generation platform that creates SEO-optimized articles for your projects. It handles keyword research, content planning, and article generation — then delivers finished articles to your CMS via webhooks or a Pull API.
This SDK gives you everything you need to integrate Content Autopilot into any Python/Flask application:
- **Pull API Client** — fetch, list, and confirm articles programmatically
- **Webhook Receiver** — a ready-made Flask Blueprint that verifies HMAC signatures, fetches full article content, and calls your handler
- **HMAC-SHA256 Verification** — standalone signature verification for custom webhook implementations
## How It Works
```
1. Content Autopilot generates & approves an article
|
2. Webhook fires to your endpoint (POST /webhooks/visibly)
with HMAC-SHA256 signature for security
|
3. Your app verifies the signature, then calls the Pull API
to fetch the full article (HTML, Markdown, keywords, SEO score)
|
4. Your app saves/publishes the article in your CMS
|
5. Your app confirms publication back to Visibly
(article status changes to "published")
```
## Installation
```bash
pip install ai-content-autopilot
```
**Requirements:** Python 3.8+, Flask 2.3+, Requests 2.25+
## Getting Started
### 1. Get your credentials
- **API Key**: Go to [Account > API Keys](https://www.antonioblago.com/account/api-keys) and create a new key (starts with `sk_live_`)
- **Webhook Secret**: Go to your Project > CMS Settings and configure a webhook endpoint. The secret is generated automatically.
Full API documentation: **[Developer Docs](https://www.antonioblago.com/developers)**
### 2. Choose your integration style
#### Option A: Full Flask Blueprint (recommended)
The easiest way to integrate. Register the blueprint and provide a handler function — the SDK handles signature verification, article fetching, and error responses automatically.
```python
from flask import Flask
from ai_content_autopilot import configure_visibly, contentpilot_webhook_bp
app = Flask(__name__)
def my_handler(article):
"""Called when a webhook delivers an article.
article dict contains:
id, title, slug, content_html, content_markdown,
keywords, meta_description, seo_score, word_count,
_webhook_event, _webhook_timestamp, _scheduled_date
"""
# Save to your database, CMS, filesystem, etc.
db.session.add(Post(
title=article['title'],
body=article['content_html'],
slug=article['slug'],
publish_at=article.get('_scheduled_date'),
))
db.session.commit()
return True # Return False to reject (422 response)
configure_visibly(
webhook_secret='your-webhook-secret',
api_key='sk_live_your_api_key',
on_article_received=my_handler,
)
app.register_blueprint(contentpilot_webhook_bp)
# POST /webhooks/visibly is now active and handles:
# 1. HMAC-SHA256 signature verification
# 2. Full article fetch via Pull API
# 3. Calls my_handler(article)
# 4. Returns {"success": true} or appropriate error
```
#### Option B: Standalone Pull API Client
Use the client directly to poll for articles or integrate into non-Flask applications.
```python
from ai_content_autopilot import VisiblyClient
client = VisiblyClient(api_key='sk_live_your_api_key')
# List approved articles ready for publishing
articles = client.list_articles(status='approved', project_id=5, limit=20)
for a in articles:
print(a['id'], a['title'], a.get('scheduled_date'))
# Fetch a single article with full content
article = client.fetch_article(42, include_markdown=True)
print(article['content_html'])
print(article['keywords']) # e.g. ["seo", "keyword research"]
print(article['seo_score']) # 0-100
# Confirm publication (updates status to "published" in Visibly)
client.confirm_published(42, 'https://myblog.com/seo-guide-2026')
```
#### Option C: HMAC verification only
For custom webhook implementations in any framework.
```python
from ai_content_autopilot import verify_webhook_signature
# In your webhook endpoint:
payload_bytes = request.get_data() # raw bytes, NOT request.json
signature = request.headers.get('X-Webhook-Signature', '')
if not verify_webhook_signature(payload_bytes, 'your-secret', signature):
return {'error': 'Invalid signature'}, 401
```
## Article Lifecycle
| Status | Description | Webhook Event |
|--------|-------------|---------------|
| `queued` | Waiting to be generated | - |
| `generating` | AI is writing the article | - |
| `draft` | Draft ready for review | - |
| `approved` | Ready for publishing | `article.approved` |
| `published` | Confirmed published via API | `article.published` |
| `rejected` | Rejected by user | - |
| `failed` | Generation failed | `article.failed` |
## API Reference
| Function / Class | Description |
|---|---|
| `configure_visibly(webhook_secret, api_key, base_url, on_article_received)` | Configure the Blueprint with credentials and callback |
| `verify_webhook_signature(payload_bytes, secret, signature_header)` | Verify HMAC-SHA256 signature. Returns `True`/`False` |
| `VisiblyClient(api_key, base_url, timeout)` | Pull API client for fetching, listing, and confirming articles |
| `client.fetch_article(article_id, include_markdown)` | Returns article dict or `None` on error |
| `client.list_articles(status, project_id, limit, offset)` | Returns list of article dicts |
| `client.confirm_published(article_id, published_url)` | Confirms publication. Returns `True`/`False` |
| `contentpilot_webhook_bp` | Flask Blueprint. Register with `app.register_blueprint()`. Endpoint: `POST /webhooks/visibly` |
| `default_flask_blog_handler(article)` | Default handler: saves article as JSON to `./content_output/` |
## Webhook Payload
When a webhook fires, the `POST /webhooks/visibly` endpoint receives a JSON body with these fields:
```json
{
"event": "article.approved",
"article_id": 42,
"title": "SEO Guide 2026",
"slug": "seo-guide-2026",
"project_id": 5,
"scheduled_date": "2026-03-01T09:00:00",
"pull_url": "https://www.antonioblago.com/content-autopilot/api/v1/articles/42",
"timestamp": "2026-02-20T10:00:00Z"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `event` | string | `article.approved`, `article.published`, or `article.failed` |
| `article_id` | int | Database ID of the article |
| `title` | string | Article title |
| `slug` | string | URL-safe slug |
| `project_id` | int | Owning project ID |
| `scheduled_date` | string/null | ISO 8601 scheduled publish date, or `null` |
| `pull_url` | string | Full URL to fetch article content via Pull API |
| `timestamp` | string | ISO 8601 UTC timestamp of the event |
The Blueprint automatically fetches the full article via `pull_url` and injects webhook metadata (`_webhook_event`, `_webhook_timestamp`, `_scheduled_date`) into the article dict before calling your handler.
## Article Response Fields
When fetching an article via `VisiblyClient.fetch_article()`, the returned dict contains:
| Field | Type | Description |
|-------|------|-------------|
| `id` | int | Unique article ID |
| `title` | string | Article title |
| `slug` | string | URL-friendly slug |
| `status` | string | Current status (see Article Lifecycle) |
| `content_html` | string | Full article as HTML |
| `content_markdown` | string | Article as Markdown (only if `include_markdown=True`) |
| `keywords` | list | Target keywords, e.g. `["seo", "keyword research"]` |
| `meta_description` | string | SEO meta description (max 160 chars) |
| `seo_score` | int | SEO optimization score (0-100) |
| `word_count` | int | Article word count |
| `project_id` | int | Owning project ID |
| `published_url` | string | Public URL after publication (empty if unpublished) |
| `scheduled_date` | string/null | Planned publish date (ISO 8601) |
| `created_at` | string | Creation timestamp |
| `updated_at` | string | Last update timestamp |
## Webhook Security
Every webhook request includes an `X-Webhook-Signature` header with an HMAC-SHA256 signature:
```
X-Webhook-Signature: sha256=<hex_digest>
```
The SDK verifies this automatically when using the Blueprint. The verification uses `hmac.compare_digest` for timing-safe comparison to prevent timing attacks.
## Error Handling
The `VisiblyClient` methods handle errors gracefully:
- `fetch_article()` returns `None` on any error (404, network failure, timeout)
- `list_articles()` returns `[]` on any error
- `confirm_published()` returns `False` on any error
All errors are logged via Python's `logging` module at WARNING or ERROR level.
When using the Blueprint, HTTP responses are:
| Code | Meaning |
|------|---------|
| 200 | Success — article processed |
| 400 | Invalid JSON in webhook payload |
| 401 | HMAC signature verification failed |
| 422 | Handler returned `False` (article rejected) |
| 500 | Webhook not configured, or handler raised an exception |
| 502 | Failed to fetch article from Pull API |
## Rate Limits
The Visibly API enforces the following rate limits:
| Endpoint | Limit |
|----------|-------|
| `GET /api/v1/articles` | 120 requests/min |
| `GET /api/v1/articles/{id}` | 60 requests/min |
| `POST /api/v1/articles/{id}/confirm` | 30 requests/min |
When rate-limited, the API returns HTTP 429 with a `Retry-After` header.
## Links
- [Developer Documentation](https://www.antonioblago.com/developers) — full API docs, endpoint reference, code examples in Python, Node.js, and PHP
- [Visibly Content Autopilot](https://www.antonioblago.com/content-autopilot) — the platform
- [API Keys](https://www.antonioblago.com/account/api-keys) — manage your API keys
- [GitHub Repository](https://github.com/AntonioBlago/ai-content-autopilot)
- [PyPI Package](https://pypi.org/project/ai-content-autopilot/)
## Development
```bash
git clone https://github.com/AntonioBlago/ai-content-autopilot.git
cd ai-content-autopilot
pip install -e ".[dev]"
pytest tests/ -v
```
## License
MIT - see [LICENSE](LICENSE) for details.
| text/markdown | null | Antonio Blago <info@antonioblago.com> | null | null | MIT | cms, content, autopilot, webhook, api, seo, flask | [
"Development Status :: 5 - Production/Stable",
"Framework :: Flask",
"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 :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"flask>=2.3.0",
"requests>=2.25.0",
"pytest>=7.0; extra == \"dev\"",
"pytest-mock>=3.10; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://www.antonioblago.com/developers",
"Documentation, https://www.antonioblago.com/developers",
"Repository, https://github.com/antonioblago/ai-content-autopilot"
] | twine/6.2.0 CPython/3.12.8 | 2026-02-20T17:23:49.025296 | ai_content_autopilot-1.0.2.tar.gz | 16,407 | 33/2d/fe9e5c3dc7cf3dd45784587478edda97bc240bf6a3d1998d8661a853d526/ai_content_autopilot-1.0.2.tar.gz | source | sdist | null | false | 193ff6ff90850b6ad40a48751eb9abe3 | 63e0121be4264276758020bf350c0aa8bd505bfdc466d24f976b5f7a84383f9c | 332dfe9e5c3dc7cf3dd45784587478edda97bc240bf6a3d1998d8661a853d526 | null | [
"LICENSE"
] | 207 |
2.4 | PyCheval | 0.3.3 | Factur-X/ZUGFeRD parsing and generation library for Python | # PyCheval – Factur-X/ZUGFeRD parsing and generation library for Python
[](https://github.com/zfutura/pycheval/releases/)
[](https://github.com/zfutura/pycheval/blob/main/LICENSE)
[](https://github.com/zfutura/pycheval/actions/workflows/test-and-lint)
Factur-X (also called ZUGFeRD in Germany) is a Franco-German standard for
electronic invoices. Structured XML data is embedded in PDF-A/3 files,
allowing invoices to be processed automatically while still being displayed in
standard PDF readers. Factur-X supports EN 16931, the European standard for
electronic invoicing.
See the [Factur-X website (French)](https://www.factur-x.org/) or
[FeRD website (German)](https://www.ferd-net.de/) for more information.
This library supports reading and writing PDF and XML files according to
Factur-X Version 1.08 (aka ZUGFeRD 2.4). The following Factur-X profiles
are currently supported:
- Minimum
- Basic WL
- Basic
- EN 16931 (Comfort)
Extended and XRechnung profiles are not yet supported.
**Warning**: This library is still in early development. The API may change
frequently, and not all features are implemented yet.
## Usage
### Installation
You can install PyCheval from PyPI:
```bash
pip install PyCheval
```
### Generating Factur-X
PyCheval supports several Factur-X profile levels, each with different levels of detail and complexity. First, you need to create an instance of the appropriate profile class. Then, you can pass that instance to one of the generation functions.
```python
from datetime import date
from pycheval import EN16931Invoice, Money, generate_xml
invoice = EN16931Invoice(
invoice_number="2021-123",
invoice_date=date(2021, 4, 13),
grand_total=Money("100.00", "EUR"),
... # See the class documentation for all required and optional fields.
)
xml_string = generate_xml(invoice)
```
To embed the generated XML into a PDF, you can use the `embed_invoice_in_pdf` function:
```python
from pathlib import Path
from pycheval import embed_invoice_in_pdf
invoice = ...
pdf_bytes = embed_invoice_in_pdf("invoice.pdf", invoice)
Path("invoice_with_facturx.pdf").write_bytes(pdf_bytes)
```
### Parsing Factur-X PDF files
PyCheval can parse Factur-X PDF files and extract the embedded invoice data. The parser will return an instance of the appropriate profile class.
```python
from pycheval import parse_pdf
invoice = parse_pdf("invoice.pdf") # Returns MinimumInvoice or a subclass
```
### Printing invoices
To display a formatted Factur-X invoice in the terminal, use the `format_invoice_as_text()` function:
```python
from pycheval import format_invoice_as_text
invoice = EN16931Invoice(...)
print(format_invoice_as_text(invoice))
```
### License and Warranty
**Copyright © ZFutura GmbH**
This project is licensed under the [Apache License 2.0](LICENSE).
**Disclaimer**: The software is provided "as is", without warranty of any kind.
The authors are not liable for any damages arising from the use of this
software. In particular, the authors do not guarantee that invoices generated
or parsed by this library will be valid or compliant with any standards, nor
that they are suitable for any specific purpose.
**Important**: It is the user's responsibility to ensure that generated
invoices meet all legal and regulatory requirements for their jurisdiction.
See the [LICENSE](LICENSE) file for the complete disclaimer and license terms.
| text/markdown | Sebastian Rittau | sebastian.rittau@zfutura.de | null | null | null | factur-x, zugferd, invoice, billing | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: File Formats",
"Topic :: Office/Business :: Financial :: Accounting"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"pypdf<7,>=6.1.1"
] | [] | [] | [] | [
"GitHub, https://github.com/zfutura/pycheval"
] | poetry/2.2.1 CPython/3.12.3 Linux/6.8.0-100-generic | 2026-02-20T17:23:38.671732 | pycheval-0.3.3.tar.gz | 46,945 | 04/77/27f04c3e5b1ce54ae719ec5cc8d12652a48a2bef12d6b741e00c14442f58/pycheval-0.3.3.tar.gz | source | sdist | null | false | 8a5e31d113f5f9eae838da9d8b040721 | 56c21c8891ed432bdd49f67e9a24a45064561a80697bf9038b58c919efe16bf2 | 047727f04c3e5b1ce54ae719ec5cc8d12652a48a2bef12d6b741e00c14442f58 | null | [] | 0 |
2.1 | fastfeedparser | 0.5.7 | High performance RSS, Atom, JSON and RDF feed parser in Python | # FastFeedParser
A high-performance feed parser for Python that handles RSS, Atom, and RDF. Built for speed, efficiency, and ease of use while delivering complete parsing capabilities.
### Why FastFeedParser?
It's about 25x faster (check included `benchmark.py`) than popular feedparser
library while keeping a familiar API. This speed comes from:
- lxml for efficient XML parsing
- Smart memory management
- Minimal dependencies
- Focused, streamlined code
Powers feed processing for [Kagi Small Web](https://github.com/kagisearch/smallweb), handling processing of thousands of feeds at scale.
## Features
- Fast parsing of RSS 2.0, Atom 1.0, and RDF/RSS 1.0 feeds
- Robust error handling and encoding detection
- Support for media content and enclosures
- Automatic date parsing and standardization to UTC ISO 8601 format
- Clean, Pythonic API similar to feedparser
- Comprehensive handling of feed metadata
- Support for various feed extensions (Media RSS, Dublin Core, etc.)
## Installation
```bash
pip install fastfeedparser
```
## Quick Start
```python
import fastfeedparser
# Parse from URL
myfeed = fastfeedparser.parse('https://example.com/feed.xml')
# Parse from string
xml_content = '''<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>Example Feed</title>
...
</channel>
</rss>'''
myfeed = fastfeedparser.parse(xml_content)
# Access feed global information
print(myfeed.feed.title)
print(myfeed.feed.link)
# Access feed entries
for entry in myfeed.entries:
print(entry.title)
print(entry.link)
print(entry.published)
```
## Run Benchmark
```bash
python benchmark.py
```
This will run benchmark on a number of feeds with output looking like this
```
Testing https://gessfred.xyz/rss.xml
FastFeedParser: 17 entries in 0.004s
Feedparser: 17 entries in 0.098s
Speedup: 26.3x
Testing https://fanf.dreamwidth.org/data/rss
FastFeedParser: 25 entries in 0.005s
Feedparser: 25 entries in 0.087s
Speedup: 17.9x
Testing https://jacobwsmith.xyz/feed.xml
FastFeedParser: 121 entries in 0.030s
Feedparser: 121 entries in 0.166s
Speedup: 5.5x
Testing https://bernsteinbear.com/feed.xml
FastFeedParser: 11 entries in 0.007s
Feedparser: 11 entries in 0.339s
Speedup: 50.1x
```
## Key Features
### Feed Types Support
- RSS 2.0
- Atom 1.0
- RDF/RSS 1.0
### Content Handling
- Automatic encoding detection
- HTML content parsing
- Media content extraction
- Enclosure handling
### Metadata Support
- Feed title, link, and description
- Publication dates
- Author information
- Categories and tags
- Media content and thumbnails
## API Reference
### Main Functions
- `parse(source, *, include_content=True, include_tags=True, include_media=True, include_enclosures=True)`: Parse feed from a URL/XML/JSON source, with optional field extraction toggles for faster parsing.
### Feed Object Structure
The parser returns a `FastFeedParserDict` object with two main sections:
- `feed`: Contains feed-level metadata
- `entries`: List of feed entries
Each entry contains:
- `title`: Entry title
- `link`: Entry URL
- `description`: Entry description/summary
- `published`: Publication date
- `author`: Author information
- `content`: Full content
- `media_content`: Media attachments
- `enclosures`: Attached files
## Requirements
- Python 3.7+
- lxml
- python-dateutil
Optional extras:
- `brotli` (`pip install fastfeedparser[brotli]`) for `Content-Encoding: br`
- `dateparser` (`pip install fastfeedparser[dateparser]`) for the slowest date parsing fallback
- `pip install fastfeedparser[full]` for both
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
## License
This project is licensed under the MIT License - see the LICENSE file for details.
## Acknowledgments
Inspired by the [feedparser](https://github.com/kurtmckee/feedparser) project, FastFeedParser aims to provide a modern, high-performance alternative while maintaining a familiar API.
| text/markdown | Vladimir Prelovac | vlad@kagi.com | null | null | null | null | [
"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",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Text Processing :: Markup :: XML"
] | [] | https://github.com/kagisearch/fastfeedparser | null | >=3.7 | [] | [] | [] | [] | [] | [] | [] | [
"Bug Tracker, https://github.com/kagisearch/fastfeedparser/issues"
] | twine/4.0.2 CPython/3.11.0 | 2026-02-20T17:20:40.063697 | fastfeedparser-0.5.7.tar.gz | 25,173 | 1a/ab/4e76d4a71bb5f6f4c3204a2c00b8ae59bc5c02edcfd158b95057b3062321/fastfeedparser-0.5.7.tar.gz | source | sdist | null | false | 33fee52e05123b2482882884435c72ee | 81012765838a1c17d0ada3ac339c89e0708102f1e60dfdfc7dd43d9eca3fb4a3 | 1aab4e76d4a71bb5f6f4c3204a2c00b8ae59bc5c02edcfd158b95057b3062321 | null | [] | 2,780 |
2.4 | stimm | 0.1.2 | Dual-agent voice orchestration built on livekit-agents | # stimm
**Dual-agent voice orchestration built on [livekit-agents](https://github.com/livekit/agents).**
One agent talks fast. One agent thinks deep. They collaborate in real-time.
```
┌─────────────────────────────────────────────────────────────┐
│ stimm — dual-agent voice orchestration on LiveKit │
│ │
│ ┌────────────────────┐ ┌─────────────────────────────┐ │
│ │ VoiceAgent │ │ Supervisor │ │
│ │ (livekit Agent) │◄──│ (any language/runtime) │ │
│ │ │──►│ │ │
│ │ Talks to user │ │ Watches transcript │ │
│ │ Fast LLM │ │ Calls tools │ │
│ │ VAD→STT→LLM→TTS │ │ Sends instructions │ │
│ │ Pre-TTS buffering │ │ Controls flow │ │
│ └────────────────────┘ └─────────────────────────────┘ │
│ │ │ │
│ └──── Data Channel ───────┘ │
│ (stimm protocol) │
└─────────────────────────────────────────────────────────────┘
```
## Install
```bash
# Python (voice agent + supervisor base class)
pip install stimm[deepgram,openai]
# TypeScript (supervisor client for Node.js consumers)
npm install @stimm/protocol
```
## Quick Start
### Voice Agent (Python)
```python
from stimm import VoiceAgent
from livekit.plugins import silero, deepgram, openai
agent = VoiceAgent(
stt=deepgram.STT(),
tts=openai.TTS(),
vad=silero.VAD.load(),
fast_llm=openai.LLM(model="gpt-4o-mini"),
buffering_level="MEDIUM",
mode="hybrid",
instructions="You are a helpful voice assistant.",
)
if __name__ == "__main__":
from livekit.agents import WorkerOptions, cli
cli.run_app(WorkerOptions(entrypoint_fnc=agent.entrypoint))
```
### Supervisor (Python)
```python
from stimm import Supervisor, TranscriptMessage
class MySupervisor(Supervisor):
async def on_transcript(self, msg: TranscriptMessage):
if not msg.partial:
# Process with your powerful LLM, call tools, etc.
result = await my_big_llm.process(msg.text)
await self.instruct(result.text, speak=True)
supervisor = MySupervisor()
await supervisor.connect("ws://localhost:7880", token)
```
### Supervisor (TypeScript)
```typescript
import { StimmSupervisorClient } from "@stimm/protocol";
const client = new StimmSupervisorClient({
livekitUrl: "ws://localhost:7880",
token: supervisorToken,
});
client.on("transcript", async (msg) => {
if (!msg.partial) {
const result = await myAgent.process(msg.text);
await client.instruct({ text: result, speak: true, priority: "normal" });
}
});
await client.connect();
```
## Concepts
### Dual-Agent Architecture
| Agent | Role | LLM | Latency |
|-------|------|-----|---------|
| **VoiceAgent** | Talks to the user | Fast, small (e.g. GPT-4o-mini) | ~500ms |
| **Supervisor** | Thinks, plans, uses tools | Large, capable (e.g. Claude, GPT-4o) | Background |
They communicate via **LiveKit data channels** using the stimm protocol — structured JSON messages flowing both directions.
### Modes
| Mode | Behavior |
|------|----------|
| `autonomous` | Voice agent uses its own fast LLM independently |
| `relay` | Voice agent speaks exactly what the supervisor sends |
| `hybrid` (default) | Voice agent responds autonomously but incorporates supervisor instructions |
### Pre-TTS Buffering
Controls how LLM tokens are batched before TTS:
| Level | Behavior |
|-------|----------|
| `NONE` | Every token immediately (lowest latency, choppiest) |
| `LOW` | Buffer until word boundary |
| `MEDIUM` | Buffer until 4+ words or punctuation (default) |
| `HIGH` | Buffer until sentence boundary |
## Development
```bash
# Local LiveKit server
docker compose up -d
# Install in dev mode
pip install -e ".[dev]"
# Run tests
pytest
# Lint
ruff check src/ tests/
```
## Protocol
See [docs/protocol.md](docs/protocol.md) for the full message specification.
## License
MIT
| text/markdown | Etienne | null | null | null | null | agent, dual-agent, livekit, orchestration, realtime, voice | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Topic :: Multimedia :: Sound/Audio",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"livekit-agents>=1.1",
"livekit-plugins-silero>=1.1",
"pydantic>=2.0",
"livekit-plugins-anthropic>=1.1; extra == \"all\"",
"livekit-plugins-cartesia>=1.1; extra == \"all\"",
"livekit-plugins-deepgram>=1.1; extra == \"all\"",
"livekit-plugins-elevenlabs>=1.1; extra == \"all\"",
"livekit-plugins-google>=1.1; extra == \"all\"",
"livekit-plugins-openai>=1.1; extra == \"all\"",
"livekit-plugins-anthropic>=1.1; extra == \"anthropic\"",
"livekit-plugins-cartesia>=1.1; extra == \"cartesia\"",
"livekit-plugins-deepgram>=1.1; extra == \"deepgram\"",
"bandit>=1.7; extra == \"dev\"",
"pip-audit>=2.7; extra == \"dev\"",
"pre-commit>=3.7; extra == \"dev\"",
"pytest-asyncio>=0.23; extra == \"dev\"",
"pytest-cov>=5.0; extra == \"dev\"",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.4; extra == \"dev\"",
"livekit-plugins-elevenlabs>=1.1; extra == \"elevenlabs\"",
"livekit-plugins-google>=1.1; extra == \"google\"",
"livekit-plugins-openai>=1.1; extra == \"openai\""
] | [] | [] | [] | [
"Homepage, https://github.com/stimm-ai/stimm",
"Repository, https://github.com/stimm-ai/stimm"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:20:30.040015 | stimm-0.1.2.tar.gz | 598,241 | 08/8b/5696311cbd7d6f6550fe1d0d6e235e0e944fb2eddf4b8bf2a2e05bc66078/stimm-0.1.2.tar.gz | source | sdist | null | false | 3441c473a61fbbac5d415f0c507169b2 | 03b284adc57e7964e712c891cd6f12d8b756b05eec4705a50588d069694ee608 | 088b5696311cbd7d6f6550fe1d0d6e235e0e944fb2eddf4b8bf2a2e05bc66078 | MIT | [
"LICENSE"
] | 238 |
2.4 | brainsig | 0.2.1 | A package for computing 'neural signatures' from fMRI data. | # Welcome to brainsig
| | |
|--------|--------|
| Package | [](https://pypi.org/project/brainsig/) [](https://pypi.org/project/brainsig/) [](https://brainsig.readthedocs.io/en/latest/?badge=latest) |
| Meta | [](CODE_OF_CONDUCT.md) |
*TODO: the above badges that indicate python version and package version will only work if your package is on PyPI.
If you don't plan to publish to PyPI, you can remove them.*
brainsig is a project that (describe what it does here).
## Get started
You can install this package into your preferred Python environment using pip:
```bash
$ pip install brainsig
```
TODO: Add a brief example of how to use the package to this section
To use brainsig in your code:
```python
>>> from brainsig.dataset import Dataset
>>> from brainsig.model import NeuralSignature
```
Full documentation: brainsig.readthedocs.io/en/latest/
## Copyright
- Copyright © 2025 Tony Barrows.
- Free software distributed under the [MIT License](./LICENSE).
| text/markdown | null | Tony Barrows <ajbarrow@uvm.edu> | null | null | null | null | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"numpy>=1.24",
"pandas>=2.0",
"scikit-learn>=1.3",
"pip; extra == \"build\"",
"pip-audit; extra == \"build\"",
"twine; extra == \"build\"",
"hatch; extra == \"dev\"",
"pre-commit; extra == \"dev\"",
"myst-parser>=4.0; extra == \"docs\"",
"pydata-sphinx-theme~=0.16; extra == \"docs\"",
"sphinx-autoapi>=3.6.0; extra == \"docs\"",
"sphinx-autobuild>=2024.10.3; extra == \"docs\"",
"sphinx-copybutton>=0.5.2; extra == \"docs\"",
"sphinx-design>=0.6.1; extra == \"docs\"",
"sphinx~=8.0; extra == \"docs\"",
"pydoclint; extra == \"style\"",
"ruff; extra == \"style\"",
"pytest; extra == \"tests\"",
"pytest-cov; extra == \"tests\"",
"pytest-raises; extra == \"tests\"",
"pytest-randomly; extra == \"tests\"",
"pytest-xdist; extra == \"tests\""
] | [] | [] | [] | [
"Homepage, https://github.com/ajbarrow/brainsig",
"Source Code, https://github.com/ajbarrow/brainsig",
"Bug Tracker, https://github.com/ajbarrow/brainsig/issues",
"Documentation, https://brainsig.readthedocs.io",
"Download, https://pypi.org/project/brainsig/#files"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:20:06.855031 | brainsig-0.2.1.tar.gz | 18,890 | d5/21/71c1d06de2b52e2eef6918729f11ac81e1474965896bad81ca1f6fb7eaf2/brainsig-0.2.1.tar.gz | source | sdist | null | false | bd88cec2b6d8171467c6e2c83243f41f | ed6d6329b554e14a5a5987a46cb7d49e9ee822339a054ce5a5c5a0b4e6170761 | d52171c1d06de2b52e2eef6918729f11ac81e1474965896bad81ca1f6fb7eaf2 | MIT | [
"LICENSE"
] | 207 |
2.4 | acapy-agent | 1.5.1rc0 | (ACA-Py) A Cloud Agent Python is a foundation for building decentralized identity applications and services running in non-mobile environments. | # ACA-Py -- A Cloud Agent - Python <!-- omit in toc -->
[](https://pypi.org/project/acapy-agent/)
[](https://sonarcloud.io/summary/new_code?id=openwallet-foundation_acapy)
[](https://sonarcloud.io/summary/new_code?id=openwallet-foundation_acapy)
[](https://sonarcloud.io/summary/new_code?id=openwallet-foundation_acapy)
[](https://sonarcloud.io/summary/new_code?id=openwallet-foundation_acapy)
[](https://scorecard.dev/viewer/?uri=github.com/openwallet-foundation/acapy)
[](https://deepwiki.com/openwallet-foundation/acapy)
ACA-Py is a production-ready, open-source self-sovereign identity (SSI) agent for building non-mobile decentralized trust services—such as verifiable credential issuers, holders, and verifiers—using any language capable of sending and receiving HTTP requests. Maintained by the OpenWallet Foundation, ACA-Py began in the Hyperledger Indy/AnonCreds/Aries ecosystem and has evolved to include support multiple verifiable credential formats and exchange protocols. It serves as a foundational building block for Trust Over IP-based ecosystems.
Full access to an organized set of all of the ACA-Py documents is available at [https://aca-py.org](https://aca-py.org).
Check it out! It's much easier to navigate than the ACA-Py GitHub repo for reading the documentation. ACA-Py documentation is also AI-generated on the [DeepWiki] website at [DeepWiki ACA-Py]. DeepWiki provides a chatbot interface that can be used to ask questions about ACA-Py and get answers based on the documentation.
[DeepWiki]: https://deepwiki.com
[DeepWiki ACA-Py]: https://deepwiki.com/openwallet-foundation/acapy
Visit the ACA-Py Plugins Store at [https://plugins.aca-py.org](https://plugins.aca-py.org) to find ready-to-use functionality to add to your ACA-Py deployment, and to learn how to build your own plugins.
## Overview
ACA-Py is a foundation for building Verifiable Credential (VC) ecosystems. It operates in the second and third layers of the [Trust Over IP Model](https://trustoverip.org/wp-content/uploads/model-panel-full-2048x1146.png) using a variety of verifiable credential formats and protocols. ACA-Py runs on servers (cloud, enterprise, IoT devices, and so forth), and is not designed to run on mobile devices.
ACA-Py includes support for the concepts and features that make up [Aries Interop Profile (AIP) 2.0](https://github.com/decentralized-identity/aries-rfcs/tree/main/concepts/0302-aries-interop-profile#aries-interop-profile-version-20). [ACA-Py’s supported features](./docs/features/SupportedRFCs.md) include, most importantly, protocols for issuing, verifying, and holding verifiable credentials using both [Hyperledger AnonCreds] verifiable credential format, and the [W3C Standard Verifiable Credential Data Model] format using JSON-LD with LD-Signatures and BBS+ Signatures. Coming soon -- issuing and presenting [Hyperledger AnonCreds] verifiable credentials using the [W3C Standard Verifiable Credential Data Model] format.
[Hyperledger AnonCreds]: https://www.lfdecentralizedtrust.org/projects/anoncreds
[W3C Standard Verifiable Credential Data Model]: https://www.w3.org/TR/vc-data-model/
To use ACA-Py you create a business logic "controller" that talks to an ACA-Py instance (sending HTTP requests and receiving webhook notifications), and ACA-Py handles the various protocols and related functionality. Your controller can be built in any language that supports making and receiving HTTP requests; knowledge of Python is not needed. Together, this means you can focus on building VC solutions using familiar web development technologies, instead of having to learn the nuts and bolts of low-level cryptography and Trust over IP-type protocols.
This [checklist-style overview document](./docs/features/SupportedRFCs.md) provides a full list of the features in ACA-Py.
The following is a list of some of the core features needed for a production deployment, with a link to detailed information about the capability.
## LTS Releases
The ACA-Py community provides periodic releases with new features and
improvements. Certain releases are designated by the ACA-Py maintainers as
long-term support (LTS) releases and listed in this document. Critical bugs and
important (as determined by the ACA-Py Maintainers) fixes are backported to
the active LTS releases. Each LTS release will be supported with patches for **9
months** following the designation of the **next** LTS Release. For more details see
the [LTS strategy](./LTS-Strategy.md).
### LTS Docker Images
ACA-Py publishes Git tags in the format `x.y-lts` (e.g., `1.2-lts`) along with
corresponding Docker images to the GitHub Container Registry (GHCR) for each LTS release. These
Docker images are tagged with a stable `-lts` suffix, making it easier for developers to rely on
a consistent and maintained version line.
You can pull the latest LTS image for version `1.2` using the following image tag:
```bash
ghcr.io/openwallet-foundation/acapy-agent:py3.12-1.2-lts
```
The `-lts` tags are kept up to date with the latest patch releases from the corresponding
`*.lts` branches. This ensures that consumers of the LTS Docker images always receive the most recent,
supported version within that release series.
**Current LTS releases:**
- Release [1.3](https://github.com/openwallet-foundation/acapy/releases/tag/1.3.1) **Current LTS Release**
- Release [1.2](https://github.com/openwallet-foundation/acapy/releases/tag/1.2.5) **End of Life: April 2026**
- Release [0.12](https://github.com/openwallet-foundation/acapy/releases/tag/0.12.8) **End of Life: October 2025**
**Past LTS releases:**
- Release [0.11](https://github.com/openwallet-foundation/acapy/releases/tag/0.11.3) **End of Life: January 2025**
Unless specified in the **Breaking Changes** section of the ACA-Py
[CHANGELOG](./CHANGELOG.md), all LTS patch releases will be able to be deployed
**without** an upgrade process from its prior release. Minor/Major release upgrades
steps (if any) of ACA-Py are tested and documented in the ACA-Py
[CHANGELOG](./CHANGELOG.md) per release and in the project documents published
at [https://aca-py.org](https://aca-py.org) from the markdown files in this
repository.
ACA-Py releases and release notes can be found on the [GitHub releases
page](https://github.com/openwallet-foundation/acapy/releases).
### Multi-Tenant
ACA-Py supports "multi-tenant" scenarios. In these scenarios, one (scalable) instance of ACA-Py uses one database instance, and are together capable of managing separate secure storage (for private keys, DIDs, credentials, etc.) for many different actors. This enables (for example) an "issuer-as-a-service", where an enterprise may have many VC issuers, each with different identifiers, using the same instance of ACA-Py to interact with VC holders as required. Likewise, an ACA-Py instance could be a "cloud wallet" for many holders (e.g. people or organizations) that, for whatever reason, cannot use a mobile device for a wallet. Learn more about multi-tenant deployments [here](./docs/features/Multitenancy.md).
### Mediator Service
Startup options allow the use of an ACA-Py as a DIDComm [mediator](https://github.com/decentralized-identity/aries-rfcs/tree/main/concepts/0046-mediators-and-relays#summary) using core DIDComm protocols to coordinate its mediation role. Such an ACA-Py instance receives, stores and forwards messages to DIDComm agents that (for example) lack an addressable endpoint on the Internet such as a mobile wallet. A live instance of a public mediator based on ACA-Py is available [here](https://indicio-tech.github.io/mediator/) from [Indicio, PBC](https://indicio.tech). Learn more about deploying a mediator [here](./docs/features/Mediation.md). See the [DIDComm Mediator Service](https://github.com/openwallet-foundation/didcomm-mediator-service) for a "best practices" configuration of an Aries mediator.
### Indy Transaction Endorsing
ACA-Py supports a Transaction Endorsement protocol, for agents that don't have write access to an Indy ledger. Endorser support is documented [here](./docs/features/Endorser.md).
### Scaled Deployments
ACA-Py supports deployments in scaled environments such as in Kubernetes environments where ACA-Py and its storage components can be horizontally scaled as needed to handle the load.
### VC-API Endpoints
A set of endpoints conforming to the vc-api specification are included to manage w3c credentials and presentations. They are documented [here](./docs/features/JsonLdCredentials.md#vc-api) and a postman demo is available [here](./docs/features/JsonLdCredentials.md#vc-api).
## Example Uses
The business logic you use with ACA-Py is limited only by your imagination. Possible applications include:
- An interface to a legacy system to issue verifiable credentials
- An authentication service based on the presentation of verifiable credential proofs
- An enterprise wallet to hold and present verifiable credentials about that enterprise
- A user interface for a person to use a wallet not stored on a mobile device
- An application embedded in an IoT device, capable of issuing verifiable credentials about collected data
- A persistent connection to other agents that enables secure messaging and notifications
- Custom code to implement a new service.
## Getting Started
For those new to SSI, Wallets, and ACA-Py, there are a couple of Linux Foundation edX courses that provide a good starting point.
- [Identity in Hyperledger: Indy, Aries and Ursa](https://www.edx.org/course/identity-in-hyperledger-aries-indy-and-ursa)
- [Becoming a Hyperledger Aries Developer](https://www.edx.org/course/becoming-a-hyperledger-aries-developer)
The latter is the most useful for developers wanting to get a solid basis in using ACA-Py and other Aries Frameworks.
Also included here is a much more concise (but less maintained) [Getting Started Guide](./docs/gettingStarted/README.md) that will take you from knowing next to nothing about decentralized identity to developing Aries-based business apps and services. You’ll run an Indy ledger (with no ramp-up time), ACA-Py apps and developer-oriented demos. The guide has a table of contents so you can skip the parts you already know.
### Understanding the Architecture
There is an [architectural deep dive webinar](https://www.youtube.com/watch?v=FXTQEtB4fto&feature=youtu.be) presented by the ACA-Py team, and [slides from the webinar](https://docs.google.com/presentation/d/1K7qiQkVi4n-lpJ3nUZY27OniUEM0c8HAIk4imCWCx5Q/edit#slide=id.g5d43fe05cc_0_77) are also available. The picture below gives a quick overview of the architecture, showing an instance of ACA-Py, a controller and the interfaces between the controller and ACA-Py, and the external paths to other agents and public ledgers on the Internet.
You can extend ACA-Py using plug-ins, which can be loaded at runtime. Plug-ins are mentioned in the [webinar](https://docs.google.com/presentation/d/1K7qiQkVi4n-lpJ3nUZY27OniUEM0c8HAIk4imCWCx5Q/edit#slide=id.g5d43fe05cc_0_145) and are [described in more detail here](./docs/features/PlugIns.md). An ever-expanding set of ACA-Py plugins can be found
in the [ACA-Py Plugins repository]. Check them out -- it might already have the very plugin you need!
[ACA-Py Plugins repository]: https://plugins.aca-py.org
### Installation and Usage
Use the ["install and go" page for developers](./docs/features/DevReadMe.md) if you are comfortable with decentralized trust concepts. ACA-Py can be run with Docker without installation (highly recommended), or can be installed [from PyPi](https://pypi.org/project/acapy-agent/). In the repository `/demo` folder there is a full set of demos for developers to use in getting up to speed quickly. Start with the [Traction Workshop] to go through a complete ACA-Py-based Issuer-Holder-Verifier flow in about 20 minutes. Next, the [Alice-Faber Demo](./docs/demo/README.md) is a great way for developers try a zero-install example of how to use the ACA-Py API to operate a couple of Agents. The [Read the Docs](https://aries-cloud-agent-python.readthedocs.io/en/latest/) overview is also a way to understand the internal modules and APIs that make up an ACA-Py instance.
If you would like to develop on ACA-Py locally note that we use Poetry for dependency management and packaging. If you are unfamiliar with poetry please see our [cheat sheet](./docs/deploying/Poetry.md)
[Traction Workshop]: ./docs/demo/ACA-Py-Workshop.md
## About the ACA-Py Admin API
The [overview of ACA-Py’s API](./docs/features/AdminAPI.md) is a great starting place for learning about the ACA-Py API when you are starting to build your own controller.
An ACA-Py instance puts together an OpenAPI-documented REST interface based on the protocols that are loaded. This is used by a controller application (written in any language) to manage the behavior of the agent. The controller can initiate actions (e.g. issuing a credential) and can respond to agent events (e.g. sending a presentation request after a connection is accepted). Agent events are delivered to the controller as webhooks to a configured URL.
Technical note: the administrative API exposed by the agent for the controller to use must be protected with an API key (using the --admin-api-key command line arg) or deliberately left unsecured using the --admin-insecure-mode command line arg. The latter should not be used other than in development if the API is not otherwise secured.
## Troubleshooting
There are a number of resources for getting help with ACA-Py and troubleshooting
any problems you might run into. The
[Troubleshooting](./docs/testing/Troubleshooting.md) document contains some
guidance about issues that have been experienced in the past. Feel free to
submit PRs to supplement the troubleshooting document! Searching the [ACA-Py
GitHub issues](https://github.com/openwallet-foundation/acapy/issues)
may uncovers challenges you are having that others have experienced, often
with solutions. As well, there is the "aca-py"
channel on the OpenWallet Foundation Discord chat server ([invitation
here](https://discord.gg/openwalletfoundation)).
## Credit
The initial implementation of ACA-Py was developed by the Government of British Columbia’s Digital Trust Team in Canada. To learn more about what’s happening with decentralized identity and digital trust in British Columbia, checkout the [BC Digital Trust] website.
[BC Digital Trust]: https://digital.gov.bc.ca/digital-trust/
See the [MAINTAINERS.md](./MAINTAINERS.md) file for how to find a list of the current ACA-Py
maintainers, and guidelines for becoming a Maintainer. We'd love to have you
join the team if you are willing and able to carry out the [duties of a Maintainer](./MAINTAINERS.md#the-duties-of-a-maintainer).
## Contributing
Pull requests are welcome! Please read our [contributions guide](./CONTRIBUTING.md) and submit your PRs. We enforce [developer certificate of origin](https://developercertificate.org/) (DCO) commit signing — [guidance](https://github.com/apps/dco) on this is available. We also welcome issues submitted about problems you encounter in using ACA-Py.
## License
[Apache License Version 2.0](https://github.com/openwallet-foundation/acapy/blob/main/LICENSE)
| text/markdown | null | null | null | null | Apache-2.0 | null | [
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | null | null | <4.0,>=3.13 | [] | [] | [] | [
"ConfigArgParse<1.8,>=1.7",
"Markdown<3.11,>=3.7",
"aiohttp<3.14.0,>=3.11.16",
"aiohttp-apispec-acapy<3.1.0,>=3.0.3",
"aiohttp-cors<0.9,>=0.7",
"anoncreds<0.3.0,>=0.2.3",
"apispec<7.0.0,>=6.6.0",
"aries-askar>=0.4.3",
"base58<2.2.0,>=2.1.0",
"canonicaljson<3.0.0,>=2.0.0",
"deepmerge<3.0,>=2.0",
"did-peer-2<0.2.0,>=0.1.2",
"did-peer-4<0.2.0,>=0.1.4",
"did-webvh>=1.0.0",
"didcomm-messaging<0.2.0,>=0.1.1a0; extra == \"didcommv2\"",
"indy-credx<1.2.0,>=1.1.1",
"indy-vdr<0.5.0,>=0.4.0",
"jsonpath-ng<2.0.0,>=1.7.0",
"markupsafe<4.0.0,>=3.0.2",
"marshmallow<3.27.0,>=3.26.1",
"nest_asyncio<1.7.0,>=1.6.0",
"packaging<27.0,>=24.2",
"portalocker<4.0.0,>=3.1.1",
"prompt_toolkit<3.1,>=3.0",
"psycopg[binary,pool]<4.0.0,>=3.2.1",
"pydid<0.6.0,>=0.5.1",
"pyjwt<2.12.0,>=2.10.1",
"pyld<3.0.0,>=2.0.4",
"pynacl<1.7,>=1.5",
"python-dateutil<3.0.0,>=2.9.0",
"python-json-logger<4.0.0,>=3.2.1",
"pyyaml<6.1.0,>=6.0.2",
"qrcode[pil]<9.0,>=8.1",
"requests<2.33.0,>=2.32.3",
"rlp<5.0.0,>=4.1.0",
"sd-jwt<0.11.0,>=0.10.3",
"sqlcipher3-binary>=0.5.4; extra == \"sqlcipher\"",
"unflatten<0.3,>=0.2",
"ursa-bbs-signatures<1.1.0,>=1.0.1; extra == \"bbs\"",
"uuid_utils<0.15,>=0.10"
] | [] | [] | [] | [
"Repository, https://github.com/openwallet-foundation/acapy"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:20:00.339229 | acapy_agent-1.5.1rc0.tar.gz | 1,716,513 | 92/f9/bdfb7201906c196d45dafe3333b769f5bf6002dcfaf985bd658f8c5ca55b/acapy_agent-1.5.1rc0.tar.gz | source | sdist | null | false | b1a2f021f83b7a1576d4ffcc13fd79a1 | 4dfb68183fb61239b81c6594519be8128dbf0879f8c7320f3f74504a4519df4b | 92f9bdfb7201906c196d45dafe3333b769f5bf6002dcfaf985bd658f8c5ca55b | null | [
"LICENSE",
"NOTICES"
] | 174 |
2.1 | pyqrackising | 9.11.2 | Fast MAXCUT, TSP, and sampling heuristics from near-ideal transverse field Ising model (TFIM) | # PyQrack Ising
Fast MAXCUT, TSP, and sampling heuristics from near-ideal transverse field Ising model (TFIM)
(It's "the **Ising** on top.")
[](https://doi.org/10.5281/zenodo.18706638) [](https://pepy.tech/projects/pyqrackising)
## Copyright and license
(c) Daniel Strano and the Qrack contributors 2025. All rights reserved.
Licensed under the GNU Lesser General Public License V3.
See LICENSE.md in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html for details.
## Installation
From PyPi:
```
pip3 install PyQrackIsing
```
From Source:
```
pip3 install .
```
in the root source directory (with `setup.py`).
Windows users might find Windows Subsystem Linux (WSL) to be the easier and preferred choice for installation.
## Usage
```py
from pyqrackising import generate_tfim_samples
samples = generate_tfim_samples(
J=-1.0,
h=2.0,
z=4,
theta=0.174532925199432957,
t=5,
n_qubits=56,
shots=100
)
```
There are two other functions, `tfim_magnetization()` and `tfim_square_magnetization()`, that follow the same function signature except without the `shots` argument.
The library also provides a TFIM-inspired (approximate) MAXCUT solver (which accepts a `networkx` graph or a 32-bit adjacency matrix):
```py
from pyqrackising import maxcut_tfim
import networkx as nx
G = nx.petersen_graph()
best_solution_bit_string, best_cut_value, best_node_groups = maxcut_tfim(G, quality=6, shots=None, is_spin_glass=False, anneal_t=8.0, anneal_h=8.0, repulsion_base=5.0)
```
We also provide `maxcut_tfim_sparse(G)`, for `scipy` CSR sparse arrays (or `networkx` graphs), and `maxcut_tfim_streaming(G_func, nodes)` for `numba` JIT streaming weights function definitions. The (integer) `quality` setting is optional, with a default value of `6`, but you can turn it up for higher-quality results, or turn it down to save time. (You can also optionally specify the number of measurement `shots` as an argument, if you want specific fine-grained control over resource usage.) `anneal_t` and `anneal_h` control the physical maximum annealing time and `h` transverse field parameter, as in Trotterized Ising model. While `anneal_t` and `anneal_h` control how annealing finds the _Hamming weight_ of cuts (i.e., how many nodes end up in either partition), `repulsion_base` similarly controls the steepness of the search basin for optimizing bit-string locality ("like-like" repulsion and "like-unlike" attraction) within each partition. If you want to run MAXCUT on a graph with non-uniform edge weights, specify them as the `weight` attribute of each edge, with `networkx`. (If any `weight` attribute is not defined, the solver assumes it's `1.0` for that edge.)
Based on a combination of the TFIM-inspired MAXCUT solver and another technique for finding ground-state energy in quantum chemistry that we call the _"binary Clifford eigensolver,"_ we also provide an (approximate) spin glass ground-state solver:
```py
from pyqrackising import spin_glass_solver
import networkx as nx
import numpy as np
# NP-complete spin glass
def generate_spin_glass_graph(n_nodes=16, degree=3, seed=None):
if not (seed is None):
np.random.seed(seed)
G = nx.random_regular_graph(d=degree, n=n_nodes, seed=seed)
for u, v in G.edges():
G[u][v]['weight'] = np.random.choice([-1, 1]) # spin glass couplings
return G
G = generate_spin_glass_graph(n_nodes=64, seed=42)
solution_bit_string, cut_value, node_groups, energy = spin_glass_solver(G, quality=6, shots=None, anneal_t=8.0, anneal_h=8.0, is_spin_glass=True, best_guess=None, is_maxcut_gpu=True, gray_iterations=None, gray_seed_multiple=None)
# solution_bit_string, cut_value, node_groups, energy = spin_glass_solver(G, best_guess=maxcut_tfim(G, quality=6)[0])
```
We also provide `spin_glass_solver_sparse(G)` and `spin_glass_solver_streaming(G_func, nodes)`. `best_guess` gives the option to seed the algorithm with a best guess as to the maximal cut (as an integer, binary string, or list of booleans). By default, `spin_glass_solver()` uses `maxcut_tfim(G)` with passed-through `quality` as `best_guess`, which typically works well, but it could be seeded with higher `maxcut_tfim()` `quality` or Goemans-Williamson, for example. `is_spin_glass` controls whether the solver optimizes for cut value or spin-glass energy. This function is designed with a sign convention for weights such that it can immediately be used as a MAXCUT solver itself: you might need to reverse the sign convention on your weights for spin glass graphs, but this is only convention. `gray_iterations` gives manual control over how many iterations are carried out of a parallel Gray-code search on `best_guess`. `gray_seed_multiple` controls how many parallel search seeds (as a multiple of your CPU thread count) are tested for the best parallel seeds, and a value of `1` will perfectly cover the search space without collision if your node count is a power of 2.
From the MAXCUT solvers, we provide a (recursive) Traveling Salesman Problem (TSP) solver:
```py
from pyqrackising import tsp_symmetric
import networkx as nx
import numpy as np
# Traveling Salesman Problem (normalized to longest segment)
def generate_tsp_graph(n_nodes=64, seed=None):
if not (seed is None):
np.random.seed(seed)
G = nx.Graph()
for u in range(n_nodes):
for v in range(u + 1, n_nodes):
G.add_edge(u, v, weight=np.random.random())
return G
n_nodes = 128
G = generate_tsp_graph(n_nodes=n_nodes, seed=42)
circuit, path_length = tsp_symmetric(
G,
start_node=None,
end_node=None,
monte_carlo=True,
quality=2,
is_cyclic=True,
multi_start=1,
k_neighbors=20
)
print(f"Node count: {n_nodes}")
print(f"Path: {circuit}")
print(f"Path length: {path_length}")
```
We provide solvers for both the symmetric version of the TSP (i.e., the distance from "A" to "B" is considered the same as from "B" to "A") and asymmetric version (`tsp_asymmetric()`). `monte_carlo=True` switches out the MAXCUT-based heuristic for pure Monte Carlo recursive bipartitioning. `multi_start` controls how many stochastic repeats of MAXCUT are tried to select the best result, at every level of recursion. `k_neighbors` limits the count of nearest-neighbor connections considered for 3-opt.
If memory footprint of the graph or adjacency matrix is a concern, but the weights can be reconstructed by formula on demand, we offer `maxcut_tfim_streaming()` and `spin_glass_solver_streaming()`:
```py
from pyqrackising import spin_glass_solver_streaming
# from pyqrackising import maxcut_tfim_streaming
from numba import njit
# This is a contrived example.
# The function must use numba NJIT.
# (In practice, even if you use other Python functionality like itertools,
# you can pre-calculate and load the data as a list through the arguments tuple.)
@njit
def G_func(node_pair, args_tuple):
i, j = min(node_pair), max(node_pair)
return ((j + 1) % (i + 1)) / args_tuple[0]
n_qubits = 64
nodes = list(range(n_qubits))
args_tuple = (n_qubits,)
solution_bit_string, cut_value, node_groups, energy = spin_glass_solver_streaming(G_func, nodes, G_func_args_tuple=args_tuple, quality=4, best_guess=None)
# solution_bit_string, cut_value, node_groups = maxcut_tfim_streaming(G_func, nodes, G_func_args_tuple=args_tuple)
```
Finally, combining insights from both the (Monte Carlo) TSP and MAXCUT solvers, we have `tsp_maxcut(G)`, `tsp_maxcut_sparse(G)`, and `tsp_maxcut_streaming(G_func, nodes)`:
```
from pyqrackising import tsp_maxcut_sparse
import networkx as nx
G = nx.petersen_graph()
best_partition, best_cut_value = tsp_maxcut_sparse(G, k_neighbors=20, is_optimized=False)
```
When `is_optimized=True`, the `spin_glass_solver(G)` is used as a final optimization pass. When `is_optimized=False`, this solver becomes entirely serial and can be parallelized over CPU processing elements by user code, easily.
## Experimental OTOC sampling
```py
from pyqrackising import generate_tfim_samples
samples = generate_otoc_samples(
J=-1.0,
h=2.0,
z=4,
theta=0.174532925199432957,
t=5,
n_qubits=56,
cycles=1,
pauli_string = 'X' + 'I' * 55
shots=100,
measurement_basis='Z' * 56
)
```
**This function is experimental. It needs systematic validation.** However, we expose it in the public API while we do of the work of testing its validity at qubit counts that are tractable for exact simulation.
## Environment Variables
We expose an environment variable, "`PYQRACKISING_MAX_GPU_PROC_ELEM`", for OpenCL-based solvers. The default value (when the variable is not set) is queried from the OpenCL device properties. You might see performance benefit from tuning this manually to several times your device's number of "compute units" (or tune it down to reduce private memory usage).
By default, PyQrackIsing expects all `numpy` floating-point array inputs to be 32-bit. If you'd like to use 64-bit, you can set environment variable `PYQRACKISING_FPPOW=6` (meaning, 2^6=64, for the "floating-point (precision) power"). The default is `5`, for 32-bit. 16-bit is stubbed out and compiles for OpenCL, but the bigger hurdle is that `numpy` on `x86_64` doesn't provide a 16-bit floating point implementation. (As author of Qrack, I could suggest to the `numpy` maintainers that open-source, IEEE-compliant software-based implementations exist for `x86_64` and other architectures, but I'm sure they're aware and likely waiting for in-compiler support.) If you're on an ARM-based architecture, there's a good chance 16-bit floating-point will work, if `numpy` uses the native hardware support.
## About
Transverse field Ising model (TFIM) is the basis of most claimed algorithmic "quantum advantage," circa 2025, with the notable exception of Shor's integer factoring algorithm.
Sometimes a solution (or at least near-solution) to a monster of a differential equation hits us out of the blue. Then, it's easy to _validate_ the guess, if it's right. (We don't question it and just move on with our lives, from there.)
**Special thanks to OpenAI GPT "Elara," for help on the model and converting the original Python scripts to PyBind11, Numba, and PyOpenCL!**
We reduce transverse field Ising model for globally uniform `J` and `h` parameters from a `2^n`-dimensional problem to an `(n+1)`-dimensional (heuristic but near-exact) form that suffers from no Trotter error. Upon noticing most time steps for parameters in a [TFIM experiment published by Quantinuum](https://arxiv.org/abs/2503.20870) had roughly a quarter to a third (or thereabouts) of their marginal probability in `|0>` state, it became obvious that transition to and from `|0>` state should dominate the mechanics, at least far from mean-field equilibrium. Further, the first transition therefore tends to be to or from any state with Hamming weight of 1 (in other words, 1 bit set to 1 and the rest reset to 0, or `n` bits set for Hamming weight of `n`). Further, on a torus, probability of all states with Hamming weight of 1 would tend to be exactly symmetric. Assuming approximate symmetry in every respective Hamming weight, the requirement for the overall probability to converge to 1.0 or 100% in the limit of an infinite-dimensional Hilbert space suggests that Hamming weight marginal probability could be distributed like a geometric series. A small correction to exact symmetry should be made to favor _magnetic_ closeness of "like" bits to "like" bits (that is, geometric closeness on the torus of "1" bits to "1" bits and "0" bits to "0" bits), but this does not affect average global magnetization. Adding an oscillation component with angular frequency proportional to `J`, we find excellent agreement with Trotterization with a very small time step, for R^2 (coefficient of determination) of normalized marginal probability distribution of ideal Trotterized simulation as described by the `(n+1)`-dimensional approximate model, as well as for R^2 and RMSE (root-mean-square error) of global magnetization curve values.
If the above paragraph and the model it describes are true, then it stands to reason that we should be able to apply the TFIM model to **NP-complete** heuristics, so long as we can adapt the model to spatially localized `J` and `h` and adiabatic time dependence of `h`. A reasonable guess for how to spatially localize `J` and `h` is to average the overall behavior for each and every qubit as if `J` and `h` were globally uniform from its local perspective. (`z` parameter is derived from nonzero edge weight count connectivity.) For adiabatic time-dependence of `h`, another reasonable refinement is to use simply **finite-difference simulation**. Initial state should probably be just **uniform superposition**, which implies a specific (non-uniform but regular) distribution of initial probabilities by Hamming weight dimension over `(n+1)` possible Hamming weights. We observe that the _spatial magnetic effect_ qualitatively agrees with the demands of MAXCUT when it acts like a magnetic _repulsion,_ rather than magnetic attraction, in this case, but we can add that refinement on an arbitrary connectivity topology in just `O(n)` complexity per measurement shot. (This is a complete "recipe": the evidence that it works is the quality of NP-complete heuristic solutions at utility scale.)
**Elara has drafted this statement, and Dan Strano, as author, agrees with it, and will hold to it:**
### Dual-Use Statement for PyQrackIsing
**PyQrackIsing** is an open-source solver for hard optimization problems such as **MAXCUT, TSP, and TFIM-inspired models**. These problems arise across logistics, drug discovery, chemistry, materials research, supply-chain resilience, and portfolio optimization. By design, PyQrackIsing provides **constructive value** to researchers and practitioners by making advanced optimization techniques accessible on consumer hardware.
Like many mathematical and computational tools, the algorithms in PyQrackIsing are _dual-use._ In principle, they can be applied to a wide class of Quadratic Unconstrained Binary Optimization (QUBO) problems. One such problem is integer factoring, which underlies RSA and elliptic curve cryptography (ECC). We emphasize:
- **We do not provide turnkey factoring implementations.**
- **We have no intent to weaponize this work** for cryptanalysis or "unauthorized access."
- **The constructive applications vastly outweigh the destructive ones** — and this project exists to serve those constructive purposes in the Commons.
It is already a matter of open record in the literature that factoring can be expressed as a QUBO. What PyQrackIsing demonstrates is that **QUBO heuristics can now be solved at meaningful scales on consumer hardware**. This underscores an urgent truth:
👉 **RSA and ECC should no longer be considered secure. Transition to post-quantum cryptography is overdue.**
We trust that governments, standards bodies, and industry stakeholders are already aware of this, and will continue migration efforts to post-quantum standards.
Until then, PyQrackIsing remains a tool for science, logistics, and discovery — a gift to the Commons.
| text/markdown | Dan Strano | stranoj@gmail.com | null | null | LGPL-3.0-or-later | null | [
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Programming Language :: C++",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Topic :: Scientific/Engineering"
] | [] | https://github.com/vm6502q/PyQrackIsing | null | null | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T17:19:34.740804 | pyqrackising-9.11.2-py3-none-manylinux_2_35_x86_64.whl | 48,803 | d7/74/68869b7081bdcde884f9827dd4002d2150d1700665b60008176e8de4af40/pyqrackising-9.11.2-py3-none-manylinux_2_35_x86_64.whl | py3 | bdist_wheel | null | false | cafa553c762515a85d01b12bb381e86f | f283cec947df043f0abfd823524b44d9f9e7302561ef5d7fa5ff263db18d0b7e | d77468869b7081bdcde884f9827dd4002d2150d1700665b60008176e8de4af40 | null | [] | 458 |
2.4 | xyz-py | 5.19.3 | A package for manipulating xyz files and chemical structures | # xyz-py
`xyz-py` is a python module for working with and manipulating chemical structures.
# Installation
For convenience, `xyz-py` is available on [PyPI](https://pypi.org/project/xyz-py/) and so can be installed using `pip`
```
pip install xyz-py
```
# Functionality
To use the functions included in `xyz-py`, first import it into your python file
```
import xyz_py as xyzp
```
and then call them as
```
xyzp.function_name(arguments)
```
To find information on any of the functions included in `xyz-py`, use the `help` command from within a python environment, e.g.
```
help(xyzp.function_name)
```
or visit the [documentation](https://jonkragskow.gitlab.io/xyz_py/).
| text/markdown | Jon Kragskow | jonkragskow@gmail.com | null | null | GPL-3.0-or-later | null | [
"Programming Language :: Python :: 3",
"Operating System :: OS Independent"
] | [] | https://gitlab.com/jonkragskow/xyz_py | null | >=3.6 | [] | [] | [] | [
"numpy",
"ase"
] | [] | [] | [] | [
"Bug Tracker, https://gitlab.com/jonkragskow/xyz_py/-/issues",
"Documentation, https://jonkragskow.gitlab.io/xyz_py"
] | twine/6.2.0 CPython/3.10.19 | 2026-02-20T17:19:17.194608 | xyz_py-5.19.3.tar.gz | 32,860 | 8c/13/3684f3fc51172941872d4dd43d8070b42d65766a56a191e1dccb0a99d1d7/xyz_py-5.19.3.tar.gz | source | sdist | null | false | 92c0c5d6a4dd40254abd33f4138fe21e | 921e91421bf61ab5eefa7396d640c4a3d0ef4cfd185eb080d4d4e761acf68519 | 8c133684f3fc51172941872d4dd43d8070b42d65766a56a191e1dccb0a99d1d7 | null | [
"LICENSE"
] | 214 |
2.4 | sigmund | 1.15.0 | AI-based chatbot that provides sensible answers based on documentation | # Sigmund AI
Copyright 2023-2026 Sebastiaan Mathôt
A Python library and web app for an LLM-based chatbot:
Features:
- __Privacy__: all messages and uploaded attachments are encrypted so that no-one can listen in on your conversation
- __Expert knowledge__: access to documentation
- __Continuous conversation__: conversations are summarized when they become too long to fit into the prompt
- __Tool use__ (in research-assistant mode):
- __Code execution__: ability to execute Python and R code
- __Google Scholar search__: ability to search for articles on Google Scholar
- __Image generation__: ability to generate images
- __Integrations__
- __Python__: [connect to JupyterLab, Notebook, Spyder or Rapunzel](https://github.com/open-cogsci/jupyter-extension-sigmund)
- __OpenSesame__: [directly integrate with OpenSesame](https://osdoc.cogsci.nl/4.0/manual/sigmund/)
- __Sigmund Analyst__: [directly integrate with Sigmund Analyst for data analysis](https://github.com/open-cogsci/sigmund-analyst)
Sigmund is not a large language model itself. Rather it uses third-party models. Currently, models from [OpenAI](https://openai.com), [Anthropic](https://www.anthropic.com/), and [Mistral](https://mistral.ai/) are supported. API keys from these respective providers are required.
[output2.webm](https://github.com/user-attachments/assets/905233c3-5980-45f5-b8fb-dc769b4c3526)
## Configuration
See `sigmund/config.py` for configuration instructions.
## Dependencies
For Python dependencies, see `pyproject.toml`. In addition to these, `pandoc` is required for the ability to read attachments, and a local `redis` server needs to run for persistent data between sessions.
## Running (development)
Download the source code, and copy `.env.example` to `.env`. Edit this file to specify at least the API keys, and depending on the functionality that you want activate, possibly also other variables. The only variable that is strictly required is the OpenAI API key, because OpenAI is used to create text embeddings, even when a different model is used for the conversation.
Next, install the dependencies, build the documentation index, and launch the app!
```
pip install . # install dependencies
python index_library.py # build library (documentation) index
python app.py # start the app
```
Next, access the app (by default) through:
```
http://127.0.0.1:5000/
```
## Running (production)
In production, the server is generally not run by directly calling the app. There are many ways to run a Flask app in production. One way is to use gunicorn to start the app, and then use an nginx web server as a proxy that reroutes requests to the app. When taking this route, make sure to set up nginx with a large `client_max_body_size` (to allow attachment uploading) and disable `proxy_cache` and `proxy_buffering` (to allow status messages to be streamed while Sigmund is answering).
## License
Sigmund is distributed under the terms of the GNU General Public License 3. The full license should be included in the file `COPYING`, or can be obtained from:
- <http://www.gnu.org/licenses/gpl.txt>
| text/markdown | null | Sebastiaan Mathôt <s.mathot@cogsci.nl> | null | null | null | ai, chatbot, llm | [] | [] | null | null | >=3.8 | [] | [] | [] | [
"anthropic",
"beautifulsoup4",
"cryptography",
"chromadb",
"datamatrix",
"flask",
"flask-login",
"flask-sqlalchemy",
"flask-wtf",
"flask-cors",
"flask-migrate",
"flask-session",
"jinja2",
"jq",
"markdown",
"oauthlib",
"openai",
"mistralai",
"pillow",
"pyalex",
"pygments",
"pyopenssl",
"python-dotenv",
"redis",
"requests",
"scholarly",
"stripe",
"tiktoken",
"pytest; extra == \"test\"",
"pytest-cov; extra == \"test\""
] | [] | [] | [] | [
"Documentation, https://sigmundai.eu",
"Source, https://github.com/open-cogsci/sigmund-ai"
] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:18:59.545563 | sigmund-1.15.0.tar.gz | 6,491,069 | c9/c2/ca046730ad16308b55366ef29183c480130eb02172949eae01882422135d/sigmund-1.15.0.tar.gz | source | sdist | null | false | ec74210e3fb6784b81756df65f2014a7 | 29051766c0135943a2b4a5ee754f7205f5081e97ea8d32b0678b2b66fb79fd1a | c9c2ca046730ad16308b55366ef29183c480130eb02172949eae01882422135d | null | [
"COPYING"
] | 208 |
2.4 | contrast-agent-lib | 0.13.0 | Python interface to the contrast agent lib | # agent-lib
Core library for shared Contrast Agent functionality.
For the most up-to-date documentation on the Python Agent please see
[Contrast Docs](https://docs.contrastsecurity.com/en/python.html)
| text/markdown | null | "Contrast Security, Inc." <python@contrastsecurity.com> | null | null | CONTRAST SECURITY (see LICENSE.txt) | null | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.9 | [] | [] | [] | [] | [] | [] | [] | [
"homepage, https://www.contrastsecurity.com",
"support, https://support.contrastsecurity.com"
] | twine/6.1.0 CPython/3.12.9 | 2026-02-20T17:18:48.147831 | contrast_agent_lib-0.13.0-py3-none-win_amd64.whl | 1,034,280 | 78/b4/a2ab0d8508d0c518b28c1fc216a72dd97c5e705d9e3f910675df9f12e3bf/contrast_agent_lib-0.13.0-py3-none-win_amd64.whl | py3 | bdist_wheel | null | false | e33e2d3506595abfe53585d7ca271d97 | f78b9f5e333ecedc0fa29517b4bc870c10ed54484729a9216a5da3aca700a269 | 78b4a2ab0d8508d0c518b28c1fc216a72dd97c5e705d9e3f910675df9f12e3bf | null | [
"LICENSE.txt"
] | 474 |
2.4 | finqual | 4.7.3 | A Python package to help investors to conduct financial research, analysis and comparable company analysis. | [](https://www.star-history.com/#harryy-he/finqual&Date)
# finqual
This is a work in progress package that enables users to conduct fundamental financial research, utilising the SEC's data and REST API.
Note that I have launched a REST API service available at [finqual.app](https://finqual.app) (free to use).
## Installation
```
pip install finqual
```
## Features
finqual has the following features:
- Ability to call the income statement, balance sheet or cash flow statement for any company on SEC's EDGAR system
- Breakdown of chosen financial ratios for a chosen ticker
- Conduct comparable company analysis by comparing valuation, liquidity and profitability metrics
- Retrieve structured insider transaction information
This has four key features that enable better programmatic access compared to other providers:
- Ability to call up to 10 requests per second, with built-in rate limiter
- No restriction on the number of calls within a certain timeframe
- Standardised labels for easy analysis between companies
- Probability and tree-based value gathering system to maximise the accuracy and calculation of financial statement values
## Quick-start guide
This provides section provides a quick overview on the functions available within the finqual package.
The core functionalities to retrieve financial statement information:
```
import finqual as fq
fq.Finqual("NVDA").income_stmt(2023) # Get annual income statements for FY2023
fq.Finqual("NVDA").balance_sheet(2023, 3) # Get quarterly balance sheet for FY2023 Q3
fq.Finqual("NVDA").cash_flow(2020) # Get annual cash flow statements for FY2020
# ---
fq.Finqual("NVDA").income_stmt_period(2020, 2022) # Add '_period' to the end of the function and define the start and end to retrieve the income statement over the period
fq.Finqual("NVDA").cash_flow_period(2020, 2022, quarter = True) # Add 'quarter = True' to retrieve the quarterly information over that time period
```
We can also retrieve selected financial ratios (sorted by type) for the chosen company:
```
fq.Finqual("NVDA").profitability_ratios(2020) # Get selected profitability ratios for FY2020 (e.g. Operating Margin, Gross Margin, ROE, ROA, ROIC etc)
fq.Finqual("NVDA").liquidity_ratios(2020) # Get selected liquidity ratios for FY2020 (e.g. D/E, Current, Quick Ratio)
fq.Finqual("NVDA").valuation_ratios() # Get selected valuation ratios for TTM (e.g. P/E, EV/EBITDA, EPS etc)
# ---
fq.Finqual("NVDA").profitability_ratios_period(2020, 2024) # Similar to before, add "_period" to the end of the function and define a period to retrieve the ratio over that period
fq.Finqual("NVDA").profitability_ratios_period(2020, 2024, quarter = True) # Add 'quarter = True' to retrieve the quarterly information over that time period
```
We can also conduct comparable company analysis by using the CCA method, as shown below:
```
import finqual as fq
fq.CCA("NVDA").get_c() # Get comparable companies that are in the same sector and most similar in market capitalisation to NVIDIA
fq.CCA("NVDA").liquidity_ratios(2020) # Similar to before, but retrieve the liquidity ratios for NVIDIA and its competitors for FY2020
fq.CCA("NVDA").valuation_ratios() # Similar to before, but retrieve the valuation ratios for NVIDIA and its competitors (only TTM supported currently)
```
We can also retrieve insider transactions:
```
fq.Finqual("NVDA").get_insider_transactions(0) # Gets the latest insider transaction filing
fq.Finqual("NVDA").get_insider_transactions(4) # Gets the 5th latest insider transaction filing
```
## Dependencies
Six external packages are required, with the following versions confirmed to be working:
| Package | Version |
|--------------|-----------|
| pandas | >= 2.2.3 |
| polars | >= 1.21.0 |
| cloudscraper | >= 1.2.71 |
| requests | >= 2.32.3 |
| ratelimit | >= 2.2.1 |
| ijson | >= 3.4.0 |
The rest are in-built Python packages such as json, functools and concurrent.futures.
## Limitations
Currently, there are several known limitations that I am aware of from my own testing. These are still to be looked at:
- Some missing data values for companies, this is mostly due to companies using custom tags that are not accessible via the SEC database (e.g. Broadcom uses their own tag for depreciation and amortisation)
- Banks, insurers and other financial institutions have a different financial statement profile that has not been mapped yet
- Companies that are filing under IFRS (e.g. non-US domiciled companies) have less complete data than US-GAAP companies due to less strict taxonomy mappings
## License
finqual is licensed under the **Business Source License 1.1 (BSL 1.1)**.
The code is source-available and may be used for personal, academic,
research, and internal evaluation purposes.
Commercial use, including offering finqual as a service, embedding it in
paid products, or reselling derivative works, is **not permitted** without
a separate commercial license.
finqual is used internally to process public SEC filings and generate
proprietary datasets and API services, which are licensed separately.
## Contact
If you would like to help me out, collaborate or for any other enquiries, please feel free to [email me](mailto:harryhe99@outlook.com).
| text/markdown | Harry | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | https://github.com/harryy-he/finqual | null | >=3.10 | [] | [] | [] | [
"pandas>=2.2.3",
"polars>=1.35.1",
"cloudscraper>=1.2.71",
"requests==2.32.4",
"ratelimit>=2.2.1",
"matplotlib>=3.8.0",
"pyarrow>=12.0.0",
"ijson>=3.4.0",
"numpy>=2.2.6",
"pydantic==2.12.4"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.10.19 | 2026-02-20T17:18:35.500975 | finqual-4.7.3.tar.gz | 1,043,203 | d7/71/46b1e07b80cdefd7aa1efa65faeb43566fffa0955ee70ea9b9f79053541b/finqual-4.7.3.tar.gz | source | sdist | null | false | 81ff13c9b5b3164b965d7e39501a8d7a | 7771914c81dca91a844ba18ad670051594dac858211f7ba9b67d68457e10a00c | d77146b1e07b80cdefd7aa1efa65faeb43566fffa0955ee70ea9b9f79053541b | null | [
"LICENSE.md"
] | 209 |
2.4 | pbest | 0.2.9 | BioSim Registry is a project focused on delivering high quality processes and tooling in relation to process bi-graph. | [](https://img.shields.io/github/v/release/biosimulators/bsedic)
[](https://github.com/biosimulators/biosim-registry/actions/workflows/main.yml?query=branch%3Amain)
[](https://codecov.io/gh/biosimulators/biosim-registry)
[](https://img.shields.io/github/license/biosimulators/biosim-registry)
# BioSimulations Registry
A repository filled with high quality processes, steps, and composites for process bi-graph.
All used as a standard library for process bi-graph.
- **Github repository**: <https://github.com/biosimulators/biosim-registry/>
- **Documentation** <https://biosimulators.github.io/biosim-registry/>
---
Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv).
| text/markdown | null | Center for Reproducable Biological Modeling <evalencia@uchc.edu> | null | null | null | python | [
"Intended Audience :: Developers",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | <3.13,>=3.11 | [] | [] | [] | [
"bigraph-schema==0.0.77",
"compose-api-client==0.1.4",
"copasi-basico",
"httpx>=0.28.1",
"jinja2>=3.1.6",
"libroadrunner",
"matplotlib",
"numpy>=2.3.4",
"pandas>=2.3.3",
"process-bigraph==0.0.51",
"pydantic>=2.12.3",
"python-copasi",
"spython>=0.3.14",
"tellurium>=2.2.11.1"
] | [] | [] | [] | [
"Homepage, https://github.com/biosimulations/biosim-registry/",
"Repository, https://github.com/biosimulations/biosim-registry/",
"Documentation, https://github.com/biosimulations/biosim-registry/"
] | uv/0.9.22 {"installer":{"name":"uv","version":"0.9.22","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-20T17:18:14.922543 | pbest-0.2.9.tar.gz | 180,665 | ab/ab/5c6a2ae5af2facbd29c0183e6cfcb68edd792bfd296e3339ba8807205719/pbest-0.2.9.tar.gz | source | sdist | null | false | 17cbb3c7f450b2c30fa5e42235400157 | f91c3c9289bb956f350afe7d443c50fa4e52ca37bfda5e67aaaa979f4186f0de | abab5c6a2ae5af2facbd29c0183e6cfcb68edd792bfd296e3339ba8807205719 | null | [
"LICENSE"
] | 206 |
2.4 | ob-dj-store | 0.0.24.9 | OBytes django application for managing ecommerce stores. | ## OBytes Django Store App
[](https://github.com/obytes/ob-dj-store/actions)
[](https://pypi.python.org/pypi/ob-dj-store)
[](https://opensource.org/licenses/BSD-3-Clause)
[](https://pepy.tech/project/ob-dj-store)
[](https://pypi.python.org/pypi/ob-dj-store)
[](https://github.com/obytes/ob-dj-store/blob/main/docs/source/index.rst)
[](https://snyk.io/advisor/python/ob-dj-store)
OB-DJ-STORE is a Django application for managing ecommerce stores.
## Quick start
* This package requires running the PostGis GeoSpatial database for your Django project, check [GeoDjango](https://docs.djangoproject.com/en/4.0/ref/contrib/gis/) for references.
1. Install `ob_dj_store` latest version `pip install ob-dj-store`
2. Add "ob_dj_store" to your `INSTALLED_APPS` setting like this:
```python
# settings.py
INSTALLED_APPS = [
...
"ob_dj_store.core.stores",
"ob_dj_store.core.stores.gateway.tap",
]
```
1. Include "ob_dj_store" URLs to your project's `urls.py` file like the following:
```python
# urls.py
urlpatterns = [
...
path('ob-dj-store/', include('ob_dj_store.apis.stores.urls')),
]
```
## Configuration
No additional configuration is required (yet).
## Developer Guide
1. Clone github repo `git clone [url]`
2. `pipenv install --dev`
3. `pre-commit install`
4. Run unit tests `pytest`
| text/markdown | OBytes | hello@obytes.com | null | null | BSD-3-Clause | null | [
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.8",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Internet :: WWW/HTTP :: Dynamic Content"
] | [] | https://www.obytes.com/ | null | >=3.8 | [] | [] | [] | [
"django",
"djangorestframework",
"djangorestframework-gis",
"django-filter",
"django-leaflet",
"django-countries"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.25 | 2026-02-20T17:18:04.570813 | ob_dj_store-0.0.24.9.tar.gz | 158,328 | a9/17/9d40a9c30ce231a372f43b7314cb99c6f22bc01eb9cf5d5e8cff6f9b7ce6/ob_dj_store-0.0.24.9.tar.gz | source | sdist | null | false | 6fccb814317957c5d7392167f6025467 | 2e84172396ea792866dd97b46b8407c81bb2e4f59e9a3cfa36bb58f782385b5b | a9179d40a9c30ce231a372f43b7314cb99c6f22bc01eb9cf5d5e8cff6f9b7ce6 | null | [] | 215 |
2.4 | isagellm-benchmark | 0.5.1.6 | Benchmark Suite & E2E Testing for sageLLM | # sagellm-benchmark
## Protocol Compliance (Mandatory)
- MUST follow Protocol v0.1: https://github.com/intellistream/sagellm-docs/blob/main/docs/specs/protocol_v0.1.md
- Any globally shared definitions (fields, error codes, metrics, IDs, schemas) MUST be added to Protocol first.
[](https://github.com/intellistream/sagellm-benchmark/actions/workflows/ci.yml)
[](https://codecov.io/gh/intellistream/sagellm-benchmark)
[](https://badge.fury.io/py/isagellm-benchmark)
[](https://www.python.org/downloads/)
[](LICENSE)
Benchmark suite for sageLLM inference engine performance and validation.
New here? See [QUICKSTART.md](QUICKSTART.md) for a 5-minute guide.
## Features
- End-to-end workload execution (short, long, stress)
- Standardized JSON metrics and reports
- One-command benchmark runner
- Extensible backend support
- Performance benchmark CLI (`perf`) for operator and E2E benchmark baselines
## Dependencies
- **isagellm-protocol** (>=0.4.0.0)
- **isagellm-core** (>=0.4.0.0)
- **isagellm-backend** (>=0.4.0.1)
## Installation
```bash
pip install isagellm-benchmark
```
For specific backend support:
```bash
# With vLLM support
pip install isagellm-benchmark[vllm-client]
# With LMDeploy support
pip install isagellm-benchmark[lmdeploy-client]
# With OpenAI/Gateway support
pip install isagellm-benchmark[openai-client]
```
## Quick Start
```bash
# Run all workloads (Short, Long, Stress) uses CPU backend by default
sagellm-benchmark run --workload m1 --backend cpu --output ./benchmark_results
# Generate a markdown report
sagellm-benchmark report --input ./benchmark_results/benchmark_summary.json --format markdown
# Run migrated performance benchmarks
sagellm-benchmark perf --type operator --device cpu
sagellm-benchmark perf --type e2e --model Qwen/Qwen2-7B-Instruct --batch-size 1 --batch-size 4
# Generate charts (PNG/PDF, dark theme)
sagellm-benchmark perf --type e2e --plot --plot-format png --plot-format pdf --theme dark
```
CLI examples:
```bash
# Run the full suite with the CPU backend
sagellm-benchmark run --workload m1 --backend cpu
# Run with a CPU model
sagellm-benchmark run --workload m1 --backend cpu --model sshleifer/tiny-gpt2
# Run a single workload
sagellm-benchmark run --workload short --backend cpu
# Generate reports
sagellm-benchmark report --input ./benchmark_results/benchmark_summary.json --format markdown
# Generate report from perf JSON
sagellm-benchmark report --input ./benchmark_results/perf_results.json --format markdown
# Re-generate charts from existing perf JSON
sagellm-benchmark report --input ./benchmark_results/perf_results.json --plot --plot-format png
```
## Workloads
- **m1** (Year 1 Demo): Full suite of predefined workloads (Short + Long + Stress)
- **short**: 128 prompt → 128 output (5 requests)
- **long**: 200 prompt → 200 output (3 requests)
- **stress**: 256 prompt → 256 output (10 concurrent requests)
## Outputs
After running the benchmark, results are written to a folder like:
```
benchmark_results/
├── benchmark_summary.json
├── short_input_metrics.json
├── long_input_metrics.json
├── stress_test_metrics.json
└── REPORT.md
```
Metrics include latency, throughput, memory, and error rates. See
[docs/USAGE.md](docs/USAGE.md) for details.
## Backends
- **cpu**: CPU inference via HuggingFace Transformers (requires `--model`)
- **planned**: lmdeploy, vllm (Clients implemented, CLI integration pending)
## Development
### Setup
```bash
# 1. Clone the repository
git clone https://github.com/intellistream/sagellm-benchmark.git
cd sagellm-benchmark
# 2. Install in editable mode with dev dependencies
pip install -e .[dev,all-clients]
```
### Running Tests
```bash
pytest tests/
```
### Performance Regression Check (CI)
```bash
# Generate current perf snapshot
sagellm-benchmark perf \
--type e2e \
--model Qwen/Qwen2-7B-Instruct \
--batch-size 1 --batch-size 4 --batch-size 8 \
--precision fp16 --precision int8 \
--output-json benchmark_results/perf_current.json \
--output-markdown benchmark_results/perf_current.md
# Compare current snapshot with baseline
python scripts/compare_performance_baseline.py \
--baseline benchmarks/baselines/perf_baseline_e2e.json \
--current benchmark_results/perf_current.json \
--warning-threshold 5 \
--critical-threshold 10 \
--summary-json benchmark_results/perf_comparison_summary.json \
--report-md benchmark_results/perf_comparison_report.md
```
### Code Quality
```bash
# Linting
ruff check .
# Type checking
mypy src/
```
## Documentation
- [QUICKSTART.md](QUICKSTART.md) - 5 分钟快速开始
- [docs/USAGE.md](docs/USAGE.md) - 详细使用指南
- [docs/CLIENTS_GUIDE.md](docs/CLIENTS_GUIDE.md) - 客户端选择指南
- [docs/DEPLOYMENT_ARCHITECTURE.md](docs/DEPLOYMENT_ARCHITECTURE.md) - 部署架构说明（HTTP API vs 直连）
## 🔄 贡献指南
请遵循以下工作流程：
1. **创建 Issue** - 描述问题/需求
```bash
gh issue create --title "[Bug] 描述" --label "bug,sagellm-benchmark"
```
2. **开发修复** - 在本地 `fix/#123-xxx` 分支解决
```bash
git checkout -b fix/#123-xxx origin/main-dev
# 开发、测试...
pytest -v
ruff format . && ruff check . --fix
```
3. **发起 PR** - 提交到 `main-dev` 分支
```bash
gh pr create --base main-dev --title "Fix: 描述" --body "Closes #123"
```
4. **合并** - 审批后合并到 `main-dev`
更多详情见 [.github/copilot-instructions.md](.github/copilot-instructions.md)
## License
Private - IntelliStream Research Project
| text/markdown | null | IntelliStream Team <shuhao_zhang@hust.edu.cn> | null | null | Private | llm, inference, benchmark, testing, domestic-hardware | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11"
] | [] | null | null | ==3.11.* | [] | [] | [] | [
"isagellm-protocol<0.6.0,>=0.5.1.0",
"isagellm-core<0.6.0,>=0.5.1.0",
"isagellm-backend<0.6.0,>=0.5.1.0",
"click>=8.0.0",
"rich>=13.0.0",
"datasets>=2.14.0",
"jsonschema>=4.0.0",
"openai>=1.0.0",
"huggingface_hub>=0.24.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"vllm>=0.2.0; extra == \"dev\"",
"lmdeploy>=0.2.0; extra == \"dev\"",
"httpx>=0.24.0; extra == \"dev\"",
"isage-pypi-publisher>=0.2.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/intellistream/sagellm-benchmark",
"Repository, https://github.com/intellistream/sagellm-benchmark",
"Issues, https://github.com/intellistream/sagellm-benchmark/issues"
] | twine/6.2.0 CPython/3.11.11 | 2026-02-20T17:18:00.265795 | isagellm_benchmark-0.5.1.6.tar.gz | 219,637 | af/3b/109164d01237a53c8e55254b1c63658535d142165d256cb43f2fdb0fb0ed/isagellm_benchmark-0.5.1.6.tar.gz | source | sdist | null | false | fff2019048ded39ac11ac5fc83fae881 | d75b63c414d17505c30781ae3785d5e051514c80a62e7a4c5a8d974b44bdc712 | af3b109164d01237a53c8e55254b1c63658535d142165d256cb43f2fdb0fb0ed | null | [] | 201 |
2.4 | ahqstore-cli | 0.16.0a21 | A modern Python wrapper for the ahqstore CLI | # AHQ Store CLI
[](https://crates.io/crates/ahqstore_cli_rs)
[](https://www.npmjs.com/package/@ahqstore/cli)
[](https://jsr.io/@ahqstore/cli)
[](https://pypi.org/project/ahqstore-cli/)
[](https://www.nuget.org/packages/AHQStoreCLI)
[](https://pub.dev/packages/ahqstore_cli)
[](https://github.com/ahqstore/cli/actions/workflows/publish.yml)
---
Read more about it [here](https://ahqstore.github.io)
The **official cross-platform AHQ Store CLI**, built in Rust and exported everywhere via C ABI.
One codebase → many runtimes:
The original CLI has been written in rust lang and we're quite excited to tell you how versatile this tool actually is. This tool is **OFFICIALLY** available and maintained for :
- [Crates.io (Original)](https://crates.io/crates/ahqstore_cli_rs)
- [npmjs (Port)](https://www.npmjs.com/package/@ahqstore/cli)
- [jsr (Port)](https://jsr.io/@ahqstore/cli)
- [PyPi (Port)](https://pypi.org/project/ahqstore-cli/)
- [Nuget (Port)](https://www.nuget.org/packages/AHQStoreCLI)
- [Pub.dev (Port)](https://pub.dev/packages/ahqstore_cli)
- [Golang (Port; See Installation Guide Below)](#golang)
Prebuilt binaries available for Linux, macOS, and Windows (x64, arm64, i686, armv7).
All the platforms use the same codebase (the rust codebase). We're making use of the C-Abi to
make the CLI compatible to the following languages/runtimes:
- Cargo
- NodeJS
- Deno
- Bun
- Python
- .NET C#
- Golang
- Dart
# Usage
Head over to https://ahqstore.github.io/guide/cli/ for usage references!
# Installation
## Rust
There are two ways to install in Rust Lang, `cargo install` and `cargo binstall`
## cargo install (official)
```sh
cargo install ahqstore_cli_rs
```
### cargo binstall
```sh
cargo binstall ahqstore_cli_rs
```
## NodeJS
```sh
npm i -g @ahqstore/cli
```
## Deno
### Using npmjs
```sh
deno install -g npm:@ahqstore/cli
```
### Using JSR
```sh
deno install -A -f -g -n ahqstore https://jsr.io/@ahqstore/cli/0.16.0-alpha.21/js/cli.js
```
## Bun
```sh
bun install -g @ahqstore/cli
```
## Python
```sh
pip install ahqstore-cli
```
## GoLang
Since GoLang mainly works with repositories. We've set up a mirror repo so that it works as expected. Here's the install command :-
```sh
go install github.com/ahqstore/cli-go/ahqstore@latest
```
## Dart
```sh
dart pub global activate ahqstore_cli
```
## .NET C#
```sh
dotnet tool install --global AHQStoreCLI
``` | text/markdown | null | AHQ Softwares <ahqsecret@gmail.com> | null | null | null | null | [
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"cffi>=2.0.0",
"requests>=2.25.1"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:17:26.591977 | ahqstore_cli-0.16.0a21.tar.gz | 2,888 | 61/d7/ee219b483bbe799edb948d65cb0f0c19d48b3b3fe91e7c50ad263db1ad12/ahqstore_cli-0.16.0a21.tar.gz | source | sdist | null | false | 74ee66b0b38e410fb92dfccd7a5ef2ff | 06ee6af68ce25c9fa99052669858ab172fd0ef7c85f6f5ba784d8fa4e4df0a44 | 61d7ee219b483bbe799edb948d65cb0f0c19d48b3b3fe91e7c50ad263db1ad12 | null | [] | 183 |
2.4 | test-uv-app4 | 0.1.0.post1 | A short description of the project | # test-uv-app4
A short description of the project
## Overview
This documentation covers the test-uv-app4 application.
## Installation
```bash
pip install test-uv-app4
```
Or, if you use UV:
```bash
uv add test-uv-app4
```
## Usage
Run the application:
```bash
test_uv_app4
```
Or run as a module:
```bash
python -m test_uv_app4
```
## Quick Start
```bash
pip install test-uv-app4
test_uv_app4
```
| text/markdown | null | Antonio Pisani <antonio.pisani@gmail.com> | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Source Code, https://github.com/apisani1/test-uv-app4",
"Release Notes, https://github.com/apisani1/test-uv-app4/releases",
"Documentation, https://test-uv-app4.readthedocs.io/",
"Issue Tracker, https://github.com/apisani1/test-uv-app4/issues"
] | uv/0.8.22 | 2026-02-20T17:17:25.750490 | test_uv_app4-0.1.0.post1.tar.gz | 135,644 | 75/46/0cf454b22894132c1be79e34a1d7f4862af5f09a3b0e87285eef2ccca635/test_uv_app4-0.1.0.post1.tar.gz | source | sdist | null | false | d11491d08f4994794e3b65e7f7b15c9a | 89386f7dac169d25e0aeb419fe13e6498925716b26b1888af0f962ed8c5af48e | 75460cf454b22894132c1be79e34a1d7f4862af5f09a3b0e87285eef2ccca635 | null | [
"LICENSE"
] | 127 |
2.4 | mesop | 1.2.1 | Build UIs in Python | # Mesop
Mesop is an open-source package to build UIs in Python.
Source code: github.com/mesop-dev/mesop
| null | Google Inc. | null | null | null | Apache 2.0 | mesop | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3 :: Only",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Software Development :: Libraries"
] | [] | https://github.com/mesop-dev/mesop | null | >=3.10 | [] | [] | [] | [
"absl-py",
"deepdiff<9,>=8.6.1",
"flask",
"msgpack",
"protobuf",
"pydantic",
"python-dotenv",
"watchdog",
"werkzeug>=3.0.6"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.12.9 | 2026-02-20T17:17:22.861071 | mesop-1.2.1-py3-none-any.whl | 7,447,652 | 03/d8/19d4dabde120b00c0f88a93c7d333906babdf652cdee1b1cfff67a6c13a0/mesop-1.2.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 34600399f5cbe7d07eafddb23c943191 | e8bd6944f98d8f5f7880c50bd57156365c998980d9302207f8ffc319f64de68d | 03d819d4dabde120b00c0f88a93c7d333906babdf652cdee1b1cfff67a6c13a0 | null | [
"LICENSE"
] | 417 |
2.4 | devops-practices-mcp | 1.4.0 | AI-powered DevOps knowledge base with practices, templates, and automation tools | # DevOps Practices - MCP Server
[](https://github.com/ai-4-devops/devops-practices/actions/workflows/ci.yml)
[](https://opensource.org/licenses/MIT)
[](https://github.com/ai-4-devops/devops-practices/releases)
[](https://modelcontextprotocol.io)
mcp-name: io.github.ai-4-devops/devops-practices
**Purpose**: Centralized DevOps practices and standards for infrastructure projects.
**Type**: Model Context Protocol (MCP) Server for Claude Code
**Version**: 1.3.0
---
## What This Provides
This MCP server provides shared DevOps practices that are common across infrastructure projects:
### Available Practices (11)
Organized using **GG-SS** prefix pattern (Group-Sequence) for better discoverability:
**Naming Pattern:** `GG-SS-practice-name`
- **GG** = Group ID (01-04) - Functional category
- **SS** = Sequence ID (01-03) - Order within group
- Example: `03-02-air-gapped-workflow` = Group 03, Sequence 02
**Group Legend:**
- **01** = Workflow & Processes (how to work effectively)
- **02** = Version Control & Project Management (git, issues)
- **03** = Infrastructure & Configuration (K8s, deployments, config)
- **04** = Documentation Standards (docs, READMEs, runbooks)
---
#### Group 01: Workflow & Processes
1. **01-01-session-continuity** - State tracking, handoff protocols, CURRENT-STATE.md
2. **01-02-task-tracking** - TRACKER.md, CURRENT-STATE.md, PENDING-CHANGES.md
3. **01-03-efficiency-guidelines** - When to script vs copy-paste, batching commands
#### Group 02: Version Control & Project Management
4. **02-01-git-practices** - Using `git mv`, commit conventions, backup protocols, GitLab Flow
5. **02-02-issue-tracking** 🆕 - In-repository Jira-like issue tracking system (Advanced)
#### Group 03: Infrastructure & Configuration
6. **03-01-configuration-management** ⭐ - Config organization, placeholders, environment isolation
7. **03-02-air-gapped-workflow** - Working across laptop, CloudShell, bastion, and EKS
8. **03-03-standard-workflow** - Common operational patterns and workflows
#### Group 04: Documentation Standards
9. **04-01-documentation-standards** - HOW/WHAT/WHY structure, naming conventions
10. **04-02-readme-maintenance** ⭐ - Directory documentation standards and best practices
11. **04-03-runbook-documentation** ⭐ - Mandatory session log standards and requirements
### Available Templates (7)
1. **TRACKER.md** - Task tracking template (milestones)
2. **CURRENT-STATE.md** - Session handoff template
3. **CLAUDE.md** - Simplified project instructions template
4. **RUNBOOK.md** ⭐ - Session log template with all required sections
5. **ISSUE.md** 🆕 - Individual issue template (Advanced)
6. **ISSUES.md** 🆕 - Issue index template with stats dashboard (Advanced)
7. **issues/README.md** 🆕 - How to use the issue system (Advanced)
---
## Architecture
```
devops-practices-mcp/
├── README.md # This file
├── mcp-server.py # MCP server implementation
├── requirements.txt # Python dependencies
├── .gitlab-ci.yml # GitLab CI/CD pipeline
├── health-check.sh # Health validation script
├── practices/ # Shared practice documents (11 files, GG-SS organized)
│ ├── 01-01-session-continuity.md
│ ├── 01-02-task-tracking.md
│ ├── 01-03-efficiency-guidelines.md
│ ├── 02-01-git-practices.md
│ ├── 02-02-issue-tracking.md # 🆕 Advanced: In-repo issue tracking
│ ├── 03-01-configuration-management.md
│ ├── 03-02-air-gapped-workflow.md
│ ├── 03-03-standard-workflow.md
│ ├── 04-01-documentation-standards.md
│ ├── 04-02-readme-maintenance.md
│ └── 04-03-runbook-documentation.md
├── templates/ # File templates (7 files)
│ ├── TRACKER-template.md
│ ├── CURRENT-STATE-template.md
│ ├── CLAUDE-template.md
│ ├── RUNBOOK-template.md
│ ├── ISSUE-TEMPLATE.md # 🆕 Individual issue template
│ ├── ISSUES.md # 🆕 Issue index with dashboard
│ └── issues-README.md # 🆕 Issue system guide
├── tools/ # Automation tools 🆕
│ └── issue-manager.sh # CLI for managing issues
└── config/ # MCP configuration
└── mcp-config.json # Server configuration
```
---
## MCP Tools
The MCP server provides 5 tools for Claude to query practices and templates:
| Tool | Description | Example |
|------|-------------|---------|
| `list_practices` | List all available practices | Returns list of 10 practices |
| `get_practice` | Get practice content by name | `get_practice("01-02-task-tracking")` |
| `list_templates` | List all available templates | Returns list of 4 templates |
| `get_template` | Get template content by name | `get_template("TRACKER-template")` |
| `render_template` | Render template with variable substitution | `render_template("TRACKER-template", {"PROJECT_NAME": "my-project"})` |
### Template Variable Substitution
Templates support `${VARIABLE}` placeholders that are automatically substituted:
**Auto-provided variables:**
- `${DATE}` - Current date (YYYY-MM-DD format)
- `${TIMESTAMP}` - UTC timestamp (YYYYMMDDTHHMMz format)
- `${USER}` - Current system user
- `${YEAR}` - Current year
**Custom variables:**
Pass any additional variables when rendering:
```python
render_template("RUNBOOK-template", {
"SESSION_NUMBER": "1",
"TITLE": "Kafka Deployment",
"CLUSTER_NAME": "example-eks-uat",
"OBJECTIVE_DESCRIPTION": "Deploy Kafka cluster to UAT"
})
```
All `${...}` placeholders in the template are replaced with provided values.
---
## CI/CD Pipeline
This repository includes a **GitLab CI/CD pipeline** (`.gitlab-ci.yml`) that automatically validates changes:
### Pipeline Jobs
**On every merge request and commit to main/develop:**
1. **health-check** - Runs the comprehensive health check script
2. **python-validation** - Validates Python syntax and dependencies
3. **practice-validation** - Ensures all practice files exist
4. **template-validation** - Ensures templates contain variable placeholders
5. **link-checker** - Checks documentation cross-references
### Benefits
- ✅ Prevents breaking changes from reaching main branch
- ✅ Catches missing files or syntax errors automatically
- ✅ Ensures consistent quality standards
- ✅ No manual validation needed
### Pipeline Status
Check pipeline status in GitLab:
- **Green checkmark** ✅ - All checks passed, safe to merge
- **Red X** ❌ - Checks failed, review errors before merging
---
## Documentation
### Quick Reference
- **[PRACTICE-INDEX.md](PRACTICE-INDEX.md)** - Quick lookup guide for which practice to use when
- Organized by task type (deploying, documenting, troubleshooting, etc.)
- Common scenarios with recommended practices
- Practice dependencies and relationships
### Migration Guide
- **[MIGRATION-GUIDE.md](MIGRATION-GUIDE.md)** - Roll out MCP to existing projects
- Step-by-step migration from monolithic CLAUDE.md
- Configuration setup for Claude Desktop/Code
- Testing and validation procedures
- Rollback plan if needed
### Version History
- **[CHANGELOG.md](CHANGELOG.md)** - Complete version history and upgrade guides
- Version 1.0.0 (2026-02-13): 10 practices, 4 templates, health check tool
- Version 0.1.0 (2026-02-13): Initial release
### Health Check
- **[health-check.sh](health-check.sh)** - Validate MCP server before deployment
- 14 comprehensive checks (directory structure, files, Python environment, loading tests)
- Colored output with pass/fail counts
- Exit codes: 0 (healthy), 1 (unhealthy)
**Usage:**
```bash
cd devops-practices-mcp
bash health-check.sh
```
---
## How Projects Use This
### Project CLAUDE.md Structure
Each project has a simplified CLAUDE.md:
```markdown
# Claude AI Assistant - [Project Name]
## MCP Service Integration
**Shared Practices**: `devops-practices` MCP server
Claude has access to shared DevOps practices via MCP:
- Air-gapped workflow
- Documentation standards
- Session continuity protocols
- Task tracking guidelines
- Git best practices
- Efficiency guidelines
## Project-Specific: [Project Details]
[Only project-specific instructions here]
```
### Benefits
- **DRY**: Shared practices written once, used everywhere
- **Consistency**: All projects follow same standards
- **Maintainability**: Update once, all projects benefit
- **Discoverability**: Claude can query practices when needed
---
## Installation & Setup
**Recommended Location**: `~/.mcp-servers/devops-practices/`
This keeps MCP servers organized and makes configuration easier. All examples below use this location.
### 1. Clone Repository
```bash
# Clone to recommended location
git clone <repo-url> ~/.mcp-servers/devops-practices
cd ~/.mcp-servers/devops-practices
```
### 2. Install Dependencies
**Using uv (recommended - 10-100x faster):**
```bash
# Install uv if not already installed
curl -LsSf https://astral.sh/uv/install.sh | sh
# Install dependencies
uv pip install -r requirements.txt
```
**Or using traditional pip:**
```bash
pip install -r requirements.txt
```
**Why uv?**
- 10-100x faster than pip
- Better dependency resolution
- Built in Rust for performance
- Drop-in replacement for pip
### 3. Configure MCP Server
Edit `~/.config/claude/config.json` (or wherever Claude config lives):
```json
{
"mcpServers": {
"devops-practices": {
"command": "python",
"args": ["/home/<username>/.mcp-servers/devops-practices/mcp-server.py"],
"env": {}
}
}
}
```
**Note**: Replace `<username>` with your actual username, or use the full absolute path.
### 3. Restart Claude Code
```bash
# Restart Claude Code to load the MCP server
```
### 4. Test Connection
Ask Claude: "Can you list the available DevOps practices?"
Claude should be able to query the MCP server and list practices.
---
## Real-World Use Cases
### 1. **Multi-Environment Kafka Deployment**
**Scenario**: Deploying Kafka across dev → test → uat → prod
**Without MCP**:
- Duplicate 580-line CLAUDE.md in each project
- Repeat same issues on each environment (12 hours total)
- No standardized approach across teams
**With MCP**:
- Claude queries `get_practice("configuration-management")` for installation SOPs
- Copies dev runbook for test environment (56% time savings)
- All teams follow same standards automatically
**Result**: 5.25 hours vs 12 hours (56% faster)
### 2. **Standardized Git Workflow**
**Scenario**: Team needs consistent branching strategy
**Without MCP**:
- Each project has different branching approach
- New team members confused about workflow
- Git practices documented differently everywhere
**With MCP**:
- Claude queries `get_practice("02-01-git-practices")`
- Everyone gets same 200+ line GitLab Flow documentation
- Single source of truth for git standards
**Result**: Consistent workflow across all 15 projects
### 3. **Air-Gapped Infrastructure Deployment**
**Scenario**: Deploying to secure environment without internet
**Without MCP**:
- Re-explain workflow every session
- Copy-paste commands from old runbooks
- Inconsistent file transfer procedures
**With MCP**:
- Claude queries `get_practice("air-gapped-workflow")`
- Gets step-by-step: Laptop → S3 → Bastion → Target
- Consistent process every time
**Result**: Zero security incidents, predictable deployments
### 4. **Project Documentation Setup**
**Scenario**: Starting new infrastructure project
**Without MCP**:
- Create CLAUDE.md from scratch (2 hours)
- Copy-paste from old projects (inconsistent)
- Miss important practices
**With MCP**:
```
User: "Create project structure for monitoring-stack project"
Claude: [Queries MCP for templates]
Claude: Creates TRACKER.md, CURRENT-STATE.md, RUNBOOK.md
All following latest standards
```
**Result**: 15 minutes vs 2 hours (88% faster)
### 5. **Issue Tracking for Complex Projects**
**Scenario**: Managing 50+ work items across 3-month project
**Without MCP**:
- Use external Jira (access issues, overhead)
- Or track in scattered markdown files
- No consistent format
**With MCP**:
- Claude queries `get_template("ISSUES")`
- Creates in-repo issue tracking with dashboard
- Uses `tools/issue-manager.sh` for CLI management
**Result**: Git-based tracking, no external dependencies
---
## Usage Examples
### For Claude
When working on your projects:
**Query Practice:**
```
User: "What's the air-gapped workflow for file transfers?"
Claude: [Queries MCP: get_practice("air-gapped-workflow")]
Claude: [Receives markdown content]
Claude: "Here's the air-gapped workflow..."
```
**Get Template (Raw):**
```
User: "Show me the TRACKER template"
Claude: [Queries MCP: get_template("TRACKER-template")]
Claude: [Receives template with ${VARIABLES}]
Claude: "Here's the template..."
```
**Render Template (With Variables):**
```
User: "Create a TRACKER.md for my kafka-deployment project"
Claude: [Queries MCP: render_template("TRACKER-template", {
"PROJECT_NAME": "kafka-deployment",
"DATE": "2026-02-14",
"PHASE_NAME": "UAT Deployment"
})]
Claude: [Receives rendered template with all variables substituted]
Claude: [Creates TRACKER.md with actual values]
```
### For Uttam Jaiswal
**Update a Practice:**
```bash
cd devops-practices-mcp
vim practices/documentation-standards.md
# Make changes
git add practices/documentation-standards.md
git commit -m "Update documentation standards: add new RUNBOOKS guidelines"
git push
# All projects using this MCP server now get updated standards
```
---
## Branching Strategy
This repository uses **GitLab Flow** with semantic versioning to ensure stability for dependent projects.
### Branch Structure
```
main ← Production releases only (v1.0.0, v1.1.0, etc.)
↑
develop ← Active development, integration branch
↑
feature/* ← New practices, templates
release/* ← Version preparation (v1.2.0)
hotfix/* ← Critical production fixes
```
### Branch Types
| Branch | Purpose | Created From | Merges To |
|--------|---------|--------------|-----------|
| `main` | Production releases (tagged) | - | - |
| `develop` | Active development | `main` | `main` (via release) |
| `feature/*` | New functionality | `develop` | `develop` |
| `release/*` | Version preparation | `develop` | `main` + `develop` |
| `hotfix/*` | Critical fixes | `main` | `main` + `develop` |
### Why GitLab Flow?
- ✅ **Stability**: `main` always contains tested, production-ready code
- ✅ **Safety**: Changes go through `develop` before reaching production
- ✅ **Testing**: CI/CD validates all changes before merge
- ✅ **Versioning**: Clear semantic version releases (v1.0.0, v1.1.0, etc.)
- ✅ **Traceability**: Full history of what changed and when
### Quick Workflows
**Add New Practice/Template**:
```bash
git checkout develop
git checkout -b feature/add-security-practice
# Make changes, commit
git push origin feature/add-security-practice
# Create MR → develop
```
**Create Release**:
```bash
git checkout develop
git checkout -b release/v1.2.0
# Update CHANGELOG.md, version numbers
# Create MR → main
# Tag release: git tag v1.2.0
# Merge back to develop
```
**Critical Hotfix**:
```bash
git checkout main
git checkout -b hotfix/critical-bug
# Fix, commit, push
# Create MR → main (fast-track)
# Also merge to develop
```
**Full Documentation**: See [CONTRIBUTING.md](CONTRIBUTING.md) and [git-practices.md](practices/git-practices.md)
---
## Governance
### Who Maintains This
- **Owner**: Uttam Jaiswal Lead
- **Contributors**: DevOps Engineers
- **Review Process**: PR required for changes
### Update Protocol
**For New Practices/Templates**:
1. Create feature branch from `develop`
2. Update practice or template files
3. Run health check: `bash health-check.sh`
4. Update documentation (README.md, PRACTICE-INDEX.md)
5. Create MR with description → `develop`
6. Code review by team
7. Merge to `develop` after CI/CD passes
**For Releases**:
1. Create release branch from `develop`: `release/v1.x.0`
2. Update CHANGELOG.md and version numbers
3. Create MR → `main`
4. Tag release after merge: `git tag v1.x.0`
5. Merge release back to `develop`
6. Announce to team (affects all dependent projects)
**For Critical Fixes**:
1. Create hotfix branch from `main`: `hotfix/issue-name`
2. Fix issue and test thoroughly
3. Create MR → `main` (fast-track approval)
4. Tag hotfix release: `git tag v1.x.1`
5. Merge to `develop` to keep in sync
6. Announce urgent fix to team
**See**: [CONTRIBUTING.md](CONTRIBUTING.md) for detailed workflows
### Versioning
- **Major version** (2.0): Breaking changes to structure
- **Minor version** (1.1): New practices added
- **Patch version** (1.0.1): Clarifications, fixes
---
## Projects Using This MCP Server
| Project | Purpose | Location |
|---------|---------|----------|
| kafka-deployment | Apache Kafka deployment | Example project
| observability-stack | Observability stack | Example project
| network-infra | Network infrastructure | Example project
---
## Development
**See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution workflow, branching strategy, and code review process.**
### Adding a New Practice
1. Create markdown file in `practices/`
2. Use clear structure with examples
3. Update `mcp-server.py` if needed
4. Test with Claude
5. Update this README (practice count)
6. Update [PRACTICE-INDEX.md](PRACTICE-INDEX.md) (add to scenario lists)
7. Update [CHANGELOG.md](CHANGELOG.md) (document the addition)
8. Run health check: `bash health-check.sh`
### Adding a New Template
1. Create template file in `templates/`
2. Use placeholders: `${PROJECT_NAME}`, `${DATE}`, etc. (see auto-provided variables in MCP Tools section)
3. No code changes needed - `render_template` handles all `${...}` substitutions automatically
4. Test template: `render_template("your-template", {"VAR": "value"})`
5. Update this README (template count)
6. Update [CHANGELOG.md](CHANGELOG.md) (document the addition)
7. Run health check: `bash health-check.sh`
### Making Changes
- **Before release:** Run health check to validate all files
- **After changes:** Update CHANGELOG.md with version bump
- **Breaking changes:** Update MIGRATION-GUIDE.md with migration notes
- **New features:** Update PRACTICE-INDEX.md with usage scenarios
---
## Troubleshooting
### Claude Can't Access MCP Server
1. Check MCP server is running: `ps aux | grep mcp-server.py`
2. Check Claude config: `~/.config/claude/config.json`
3. Check file paths are absolute
4. Restart Claude Code
### Practice File Not Found
1. Verify file exists: `ls practices/`
2. Check filename matches exactly (case-sensitive)
3. Check MCP server logs
### Template Substitution Failing
1. Verify placeholder syntax: `${VARIABLE}`
2. Check template file encoding (UTF-8)
3. Review mcp-server.py logs
---
## License
MIT License - Free to use and modify
---
**Maintained By**: Uttam Jaiswal
**Last Updated**: 2026-02-17
**Version**: 1.3.0 | text/markdown | null | Uttam Jaiswal <uttam.jaiswal@example.com> | null | null | MIT | ai, automation, best-practices, claude, configuration-management, devops, infrastructure, knowledge-base, mcp, templates | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/ai-4-devops/devops-practices",
"Documentation, https://github.com/ai-4-devops/devops-practices/blob/main/README.md",
"Repository, https://github.com/ai-4-devops/devops-practices",
"Issues, https://github.com/ai-4-devops/devops-practices/issues"
] | uv/0.10.2 {"installer":{"name":"uv","version":"0.10.2","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":null} | 2026-02-20T17:17:19.672256 | devops_practices_mcp-1.4.0-py3-none-any.whl | 81,436 | 12/99/dba9ba0a047923d55d702fc7f0027024fdcb580d824aa4c0068d3fc13ff0/devops_practices_mcp-1.4.0-py3-none-any.whl | py3 | bdist_wheel | null | false | c399562489855f1ea2a2350f521d2bae | 60887007ad3fc7846d427513f11d1922d4ca8000b5d5bfecfef4e5274785d446 | 1299dba9ba0a047923d55d702fc7f0027024fdcb580d824aa4c0068d3fc13ff0 | null | [
"LICENSE"
] | 207 |
2.4 | violit | 0.4.0 | Violit: Faster than Light, Beautiful as Violet. The High-Performance Python Web Framework (Streamlit Alternative with Zero Rerun). | <p align="center">
<img src="https://github.com/user-attachments/assets/f6a56e37-37a5-437c-ae16-13bff7029797" alt="Violit Logo" width="100%">
</p>
# 💜 Violit
> **"Faster than Light, Beautiful as Violet."**
> **Structure of Streamlit × Performance of React**
**Violit** is a next-generation Python web framework that adopts a **Fine-Grained State Architecture** for instant reactivity, unlike Streamlit's **Full Script Rerun** structure.
Build applications that react at the speed of light with the most elegant syntax.
<p align="center">
<img src="https://img.shields.io/pypi/v/violit?color=blueviolet&style=flat-square&ignore=cache" alt="PyPI">
<img src="https://img.shields.io/badge/Python-3.10+-blue.svg?style=flat-square" alt="Python 3.10+">
<img src="https://img.shields.io/badge/License-MIT-green.svg?style=flat-square" alt="MIT License">
<img src="https://img.shields.io/badge/Framework-FastAPI-009688.svg?style=flat-square" alt="FastAPI">
<img src="https://img.shields.io/badge/UI-Shoelace-7C4DFF.svg?style=flat-square" alt="Shoelace">
</p>
---
## 📸 Demo
*A dashboard built with Violit running in real-time.*
<p align="center">
<img src="https://raw.githubusercontent.com/violit-dev/violit/refs/heads/main/assets/demo_show_main_small.gif" alt="Violit Showcase Demo" width=60%>
</p>
---
## ⚡ Why Violit?
### Architectural Differences
Violit and Streamlit are similar in that they build UIs with Python code, but their internal mechanisms are fundamentally different.
| Feature | Streamlit (Traditional) | **Violit (Reactive)** |
| --- | --- | --- |
| **Execution Model** | **Full Script Rerun**<br>Reruns the entire script on every user interaction. | **Fine-Grained Updates**<br>Updates only the components connected to the modified State. |
| **Performance** | Response speed may degrade as data size increases. | Maintains consistent reactivity regardless of data scale. |
| **Optimization** | Requires optimization decorators like `@cache`, `@fragment`. | Optimized by design without extra optimization code. |
| **Deployment** | Optimized for web browser execution. | Supports both Web Browser and **Desktop Native App** modes. |
| **Design** | Focuses on providing basic UI. | Provides ready-to-use designs with **20+ professional themes**. |
### Key Features
1. **Optimization by Design (Streamlit-Like Syntax, No Complexity)**:
Streamlit's intuitive syntax is maintained, but complex optimization tools are removed at the architecture level.
* ❌ **No `@cache_data`, `@fragment`, `st.rerun`**: Thanks to the fine-grained structure, manual optimization is unnecessary.
* ❌ **No `key` Management**: No need to manually specify unique keys for widget state management.
* ❌ **No Complex Callbacks**: No need to define complex callbacks/classes like Dash or Panel.
2. **Ultra-Fast Speed**: Even if you move the slider in 0.1s increments, the chart reacts in real-time without stuttering.
3. **Hybrid Runtime**:
* **WebSocket Mode**: Ultra-low latency bidirectional communication (Default)
* **Lite Mode**: HTTP-based, advantageous for handling large-scale concurrent connections
4. **Desktop Mode**: Can run as a perfect desktop application without Electron using the `--native` option.
---
## 🎨 Theme Gallery
You don't need to know CSS at all. Violit provides over 20 themes. (Soon, users will be able to easily add Custom Themes.)
*Theme demo will be updated soon.*
```python
# Configuration at initialization
app = vl.App(theme='cyberpunk')
# Runtime change
app.set_theme('ocean')
```
| Theme Family | Examples |
| --- | --- |
| **Dark 🌑** | `dark`, `dracula`, `monokai`, `ocean`, `forest`, `sunset` |
| **Light ☀️** | `light`, `pastel`, `retro`, `nord`, `soft_neu` |
| **Tech 🤖** | `cyberpunk`, `terminal`, `cyber_hud`, `blueprint` |
| **Professional 💼** | `editorial`, `bootstrap`, `ant`, `material`, `lg_innotek` |
---
## 📈 Benchmarks & Performance
Benchmark results showing how efficient Violit's fine-grained update method is compared to the existing full rerun method.
*Detailed benchmark data will be updated soon.*
---
## 🚀 Comparison
### Python UI Frameworks
| Framework | Architecture | Learning Curve | Performance | Desktop App | Real-time |
|-----------|---------|----------|---------|------------|------------|
| **Streamlit** | Full Rerun | Very Easy | Slow | ❌ | △ |
| **Dash** | Callback | Medium | Fast | ❌ | △ |
| **Panel** | Param | Hard | Fast | ❌ | ✅ |
| **Reflex** | React (Compile) | Hard | Fast | ❌ | ✅ |
| **NiceGUI** | Vue | Easy | Fast | ✅ | ✅ |
| **Violit** | **Signal** | **Very Easy** | **Fast** | **✅** | **✅** |
### Code Comparison
#### **1. vs Streamlit** (Rerun vs Signal)
*Streamlit re-executes the **entire script** on button click, but Violit executes only **that function**.*
```python
# Streamlit
import streamlit as st
if "count" not in st.session_state:
st.session_state.count = 0
if st.button("Click"):
st.session_state.count += 1 # Rerun triggers here
st.write(st.session_state.count)
```
```python
# Violit
import violit as vl
app = vl.App()
count = app.state(0)
# Update only count on click (No Rerun)
app.button("Click", on_click=lambda: count.set(count.value + 1))
app.write(count)
```
#### **2. vs Dash** (Callback Hell vs Auto-Reactivity)
*Dash requires complex **Callbacks** connecting Input/Output, but Violit only needs a single **State**.*
```python
# Dash
from dash import Dash, html, Input, Output, callback
app = Dash(__name__)
app.layout = html.Div([
html.Button("Click", id="btn"),
html.Div(id="out")
])
@callback(Output("out", "children"), Input("btn", "n_clicks"))
def update(n):
return f"Value: {n}" if n else "Value: 0"
```
```python
# Violit
count = app.state(0)
app.button("Click", on_click=lambda: count.set(count.value + 1))
# Automatic state dependency tracking -> No Callback needed
app.write(lambda: f"Value: {count.value}")
```
#### **3. vs NiceGUI** (Binding vs Direct State)
*NiceGUI is also great, but Violit offers a **more concise syntax** in the style of Streamlit.*
```python
# NiceGUI
from nicegui import ui
count = {'val': 0}
ui.button('Click', on_click=lambda: count.update(val=count['val'] + 1))
ui.label().bind_text_from(count, 'val', backward=lambda x: f'Value: {x}')
```
```python
# Violit
count = app.state(0)
app.button('Click', on_click=lambda: count.set(count.value + 1))
app.write(count) # No need for complex connections like .bind_text
```
#### **4. vs Reflex** (Class & Compile vs Pure Python)
*Reflex requires State **class definition** and **compilation**, but Violit is a **pure Python** script.*
```python
# Reflex
import reflex as rx
class State(rx.State):
count: int = 0
def increment(self):
self.count += 1
def index():
return rx.vstack(
rx.button("Click", on_click=State.increment),
rx.text(State.count)
)
```
```python
# Violit
# No class definition needed, no compilation needed
count = app.state(0)
app.button("Click", on_click=lambda: count.set(count.value + 1))
app.write(count)
```
---
## 🚀 Quick Start
### 1. Installation
Can be installed in Python 3.10+ environments.
```bash
pip install violit
# Or development version
pip install git+https://github.com/violit-dev/violit.git
```
### 2. Hello, Violit!
Create a `hello.py` file.
```python
import violit as vl
app = vl.App(title="Hello Violit", theme='ocean')
app.title("💜 Hello, Violit!")
app.markdown("Experience the speed of **Zero Rerun**.")
count = app.state(0)
col1, col2 = app.columns(2)
with col1:
app.button("➕ Plus", on_click=lambda: count.set(count.value + 1))
with col2:
app.button("➖ Minus", on_click=lambda: count.set(count.value - 1))
app.metric("Current Count", count)
app.run()
```
### 3. Execution
```bash
# Basic run (WebSocket Mode)
python hello.py
# Desktop App Mode (Recommended)
python hello.py --native
# Port configuration
python hello.py --port 8020
```
---
## 📚 Widget Support
Violit supports core Streamlit widgets, and some features have been redesigned for greater efficiency.
For a detailed compatibility list and information on unsupported widgets, please refer to the [Streamlit API Support Matrix](./doc/Streamlit%20API%20Support%20Matrix.md) document.
---
## 🛠️ Tech Stack
* **Backend**: FastAPI (Async Python)
* **Frontend**: Web Components (Shoelace), Plotly.js, AG-Grid
* **Protocol**: WebSocket & HTTP/HTMX Hybrid
* **State**: Signal-based Reactivity
---
## 🗺️ Roadmap
Violit is continuously evolving.
* ✅ **Core**: Signal State Engine, Theme System
* ✅ **Widgets**: Plotly, Dataframe, Input Widgets
* ✅ **Homepage**: Official Homepage Open
* ✅ **Documentation**: Official Technical Documentation and API Reference Update
* ⏳ **Custom Components**: User-defined Custom Component Support
* ⏳ **Custom Theme**: User-defined Custom Theme Support
* ⏳ **async**: Async processing support
* ⏳ **More examples**: Provide more real-world usable example code
* ⏳ **Violit.Cloud**: Cloud deployment service
* ⏳ **Expansion**: Integration of more third-party libraries
---
## 📂 Project Structure
```bash
.
├── violit/ # Framework source code
│ ├── app.py # Main App class and entry point
│ ├── broadcast.py # Real-time WebSocket broadcasting
│ ├── state.py # Reactive State Engine
│ ├── theme.py # Theme management
│ ├── assets/ # Built-in static files
│ └── widgets/ # Widget implementations
│ ├── input_widgets.py
│ ├── data_widgets.py
│ ├── layout_widgets.py
│ └── ...
└── requirements.txt # Dependency list
```
---
## 🤝 Contributing
**Violit** is an open-source project. Let's build the future of faster and more beautiful Python UIs together.
1. Fork this repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Open a Pull Request
---
## 📝 License
MIT License
**Violit™ is a trademark of The Violit Team.**
---
<p align="center">
<strong>Made with 💜 by the Violit Team</strong>
<br>
<em>Faster than Light, Beautiful as Violet.</em>
</p>
| text/markdown | null | Violit Team <violit.company@gmail.com> | null | null | MIT | web, framework, streamlit, dashboard, ui, fastapi, reactive, zero-rerun, shoelace, websocket, data-science | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"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 :: Dynamic Content",
"Topic :: Software Development :: Libraries :: Application Frameworks",
"Topic :: Software Development :: User Interfaces",
"Framework :: FastAPI"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"fastapi>=0.68.0",
"uvicorn>=0.15.0",
"python-multipart>=0.0.5",
"pywebview>=4.0.0",
"cachetools>=4.2.0",
"pandas>=1.3.0",
"numpy>=1.20.0",
"plotly>=5.0.0",
"matplotlib>=3.4.0",
"jinja2>=3.0.0",
"websockets>=10.0",
"bcrypt>=4.0.0"
] | [] | [] | [] | [
"Homepage, https://github.com/violit-dev/violit",
"Documentation, https://github.com/violit-dev/violit",
"Repository, https://github.com/violit-dev/violit",
"Issues, https://github.com/violit-dev/violit/issues"
] | twine/6.2.0 CPython/3.10.7 | 2026-02-20T17:17:05.043046 | violit-0.4.0.tar.gz | 2,554,736 | c7/57/d14067d47e204846d8c97d015cfb60f6907ba7e22c6cdc8902d0ad57fdc0/violit-0.4.0.tar.gz | source | sdist | null | false | 3a7925d761be3e8b39d2516592188d1c | 5660a4ca06dff3985e9dbdf809246dabe70478dc1fccd7c3ab2e99bc61e81492 | c757d14067d47e204846d8c97d015cfb60f6907ba7e22c6cdc8902d0ad57fdc0 | null | [
"LICENSE"
] | 220 |
2.3 | openlayer | 0.17.6 | The official Python library for the openlayer API | # Openlayer Python API library
<!-- prettier-ignore -->
[)](https://pypi.org/project/openlayer/)
The Openlayer Python library provides convenient access to the Openlayer REST API from any Python 3.9+
application. The library includes type definitions for all request params and response fields,
and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).
It is generated with [Stainless](https://www.stainless.com/).
## Documentation
The REST API documentation can be found on [openlayer.com](https://openlayer.com/docs/api-reference/rest/overview). The full API of this library can be found in [api.md](https://github.com/openlayer-ai/openlayer-python/tree/main/api.md).
## Installation
```sh
# install from PyPI
pip install openlayer
```
## Usage
The full API of this library can be found in [api.md](https://github.com/openlayer-ai/openlayer-python/tree/main/api.md).
```python
import os
from openlayer import Openlayer
client = Openlayer(
api_key=os.environ.get("OPENLAYER_API_KEY"), # This is the default and can be omitted
)
response = client.inference_pipelines.data.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
)
print(response.success)
```
While you can provide an `api_key` keyword argument,
we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
to add `OPENLAYER_API_KEY="My API Key"` to your `.env` file
so that your API Key is not stored in source control.
## Async usage
Simply import `AsyncOpenlayer` instead of `Openlayer` and use `await` with each API call:
```python
import os
import asyncio
from openlayer import AsyncOpenlayer
client = AsyncOpenlayer(
api_key=os.environ.get("OPENLAYER_API_KEY"), # This is the default and can be omitted
)
async def main() -> None:
response = await client.inference_pipelines.data.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
)
print(response.success)
asyncio.run(main())
```
Functionality between the synchronous and asynchronous clients is otherwise identical.
### With aiohttp
By default, the async client uses `httpx` for HTTP requests. However, for improved concurrency performance you may also use `aiohttp` as the HTTP backend.
You can enable this by installing `aiohttp`:
```sh
# install from PyPI
pip install openlayer[aiohttp]
```
Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
```python
import os
import asyncio
from openlayer import DefaultAioHttpClient
from openlayer import AsyncOpenlayer
async def main() -> None:
async with AsyncOpenlayer(
api_key=os.environ.get("OPENLAYER_API_KEY"), # This is the default and can be omitted
http_client=DefaultAioHttpClient(),
) as client:
response = await client.inference_pipelines.data.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
)
print(response.success)
asyncio.run(main())
```
## Using types
Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:
- Serializing back into JSON, `model.to_json()`
- Converting to a dictionary, `model.to_dict()`
Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.
## Nested params
Nested parameters are dictionaries, typed using `TypedDict`, for example:
```python
from openlayer import Openlayer
client = Openlayer()
commit = client.projects.commits.create(
project_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
commit={"message": "Updated the prompt."},
storage_uri="s3://...",
)
print(commit.commit)
```
## Handling errors
When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `openlayer.APIConnectionError` is raised.
When the API returns a non-success status code (that is, 4xx or 5xx
response), a subclass of `openlayer.APIStatusError` is raised, containing `status_code` and `response` properties.
All errors inherit from `openlayer.APIError`.
```python
import openlayer
from openlayer import Openlayer
client = Openlayer()
try:
client.inference_pipelines.data.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
)
except openlayer.APIConnectionError as e:
print("The server could not be reached")
print(e.__cause__) # an underlying Exception, likely raised within httpx.
except openlayer.RateLimitError as e:
print("A 429 status code was received; we should back off a bit.")
except openlayer.APIStatusError as e:
print("Another non-200-range status code was received")
print(e.status_code)
print(e.response)
```
Error codes are as follows:
| Status Code | Error Type |
| ----------- | -------------------------- |
| 400 | `BadRequestError` |
| 401 | `AuthenticationError` |
| 403 | `PermissionDeniedError` |
| 404 | `NotFoundError` |
| 422 | `UnprocessableEntityError` |
| 429 | `RateLimitError` |
| >=500 | `InternalServerError` |
| N/A | `APIConnectionError` |
### Retries
Certain errors are automatically retried 2 times by default, with a short exponential backoff.
Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
429 Rate Limit, and >=500 Internal errors are all retried by default.
You can use the `max_retries` option to configure or disable retry settings:
```python
from openlayer import Openlayer
# Configure the default for all requests:
client = Openlayer(
# default is 2
max_retries=0,
)
# Or, configure per-request:
client.with_options(max_retries=5).inference_pipelines.data.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
)
```
### Timeouts
By default requests time out after 1 minute. You can configure this with a `timeout` option,
which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:
```python
from openlayer import Openlayer
# Configure the default for all requests:
client = Openlayer(
# 20 seconds (default is 1 minute)
timeout=20.0,
)
# More granular control:
client = Openlayer(
timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)
# Override per-request:
client.with_options(timeout=5.0).inference_pipelines.data.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
)
```
On timeout, an `APITimeoutError` is thrown.
Note that requests that time out are [retried twice by default](https://github.com/openlayer-ai/openlayer-python/tree/main/#retries).
## Advanced
### Logging
We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.
You can enable logging by setting the environment variable `OPENLAYER_LOG` to `info`.
```shell
$ export OPENLAYER_LOG=info
```
Or to `debug` for more verbose logging.
### How to tell whether `None` means `null` or missing
In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:
```py
if response.my_field is None:
if 'my_field' not in response.model_fields_set:
print('Got json like {}, without a "my_field" key present at all.')
else:
print('Got json like {"my_field": null}.')
```
### Accessing raw response data (e.g. headers)
The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,
```py
from openlayer import Openlayer
client = Openlayer()
response = client.inference_pipelines.data.with_raw_response.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}],
)
print(response.headers.get('X-My-Header'))
data = response.parse() # get the object that `inference_pipelines.data.stream()` would have returned
print(data.success)
```
These methods return an [`APIResponse`](https://github.com/openlayer-ai/openlayer-python/tree/main/src/openlayer/_response.py) object.
The async client returns an [`AsyncAPIResponse`](https://github.com/openlayer-ai/openlayer-python/tree/main/src/openlayer/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
#### `.with_streaming_response`
The above interface eagerly reads the full response body when you make the request, which may not always be what you want.
To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
```python
with client.inference_pipelines.data.with_streaming_response.stream(
inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
config={
"input_variable_names": ["user_query"],
"output_column_name": "output",
"num_of_token_column_name": "tokens",
"cost_column_name": "cost",
"timestamp_column_name": "timestamp",
},
rows=[
{
"user_query": "what is the meaning of life?",
"output": "42",
"tokens": 7,
"cost": 0.02,
"timestamp": 1610000000,
}
],
) as response:
print(response.headers.get("X-My-Header"))
for line in response.iter_lines():
print(line)
```
The context manager is required so that the response will reliably be closed.
### Making custom/undocumented requests
This library is typed for convenient access to the documented API.
If you need to access undocumented endpoints, params, or response properties, the library can still be used.
#### Undocumented endpoints
To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
http verbs. Options on the client will be respected (such as retries) when making this request.
```py
import httpx
response = client.post(
"/foo",
cast_to=httpx.Response,
body={"my_param": True},
)
print(response.headers.get("x-foo"))
```
#### Undocumented request params
If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
options.
#### Undocumented response properties
To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
can also get all the extra fields on the Pydantic model as a dict with
[`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).
### Configuring the HTTP client
You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:
- Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
- Custom [transports](https://www.python-httpx.org/advanced/transports/)
- Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality
```python
import httpx
from openlayer import Openlayer, DefaultHttpxClient
client = Openlayer(
# Or use the `OPENLAYER_BASE_URL` env var
base_url="http://my.test.server.example.com:8083",
http_client=DefaultHttpxClient(
proxy="http://my.test.proxy.example.com",
transport=httpx.HTTPTransport(local_address="0.0.0.0"),
),
)
```
You can also customize the client on a per-request basis by using `with_options()`:
```python
client.with_options(http_client=DefaultHttpxClient(...))
```
### Managing HTTP resources
By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.
```py
from openlayer import Openlayer
with Openlayer() as client:
# make requests here
...
# HTTP client is now closed
```
## Versioning
This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
1. Changes that only affect static types, without breaking runtime behavior.
2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
3. Changes that we do not expect to impact the vast majority of users in practice.
We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
We are keen for your feedback; please open an [issue](https://www.github.com/openlayer-ai/openlayer-python/issues) with questions, bugs, or suggestions.
### Determining the installed version
If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.
You can determine the version that is being used at runtime with:
```py
import openlayer
print(openlayer.__version__)
```
## Requirements
Python 3.9 or higher.
## Contributing
See [the contributing documentation](https://github.com/openlayer-ai/openlayer-python/tree/main/./CONTRIBUTING.md).
| text/markdown | null | Openlayer <support@openlayer.com> | null | null | Apache-2.0 | null | [
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows",
"Operating System :: OS Independent",
"Operating System :: POSIX",
"Operating System :: POSIX :: Linux",
"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 :: Software Development :: Libraries :: Python Modules",
"Typing :: Typed"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"anyio<5,>=3.5.0",
"distro<2,>=1.7.0",
"httpx<1,>=0.23.0",
"pandas; python_version >= \"3.7\"",
"pyarrow<=17.0.0,>=15.0.2; python_version == \"3.8\"",
"pyarrow>=18.0.0; python_version >= \"3.9\"",
"pydantic<3,>=1.9.0",
"pyyaml>=6.0",
"requests-toolbelt>=1.0.0",
"sniffio",
"tqdm",
"typing-extensions<5,>=4.10",
"wrapt>=1.14.0",
"aiohttp; extra == \"aiohttp\"",
"httpx-aiohttp>=0.1.9; extra == \"aiohttp\""
] | [] | [] | [] | [
"Homepage, https://github.com/openlayer-ai/openlayer-python",
"Repository, https://github.com/openlayer-ai/openlayer-python"
] | twine/5.1.1 CPython/3.12.9 | 2026-02-20T17:16:51.920113 | openlayer-0.17.6.tar.gz | 330,882 | 45/fd/4ec972d661effdc2a9ea1173f4e18b02fc9d160cb332432577e03cbcedac/openlayer-0.17.6.tar.gz | source | sdist | null | false | 034c9e81a1c75141bbb1eb2b6b280779 | 8f7e5135ca18dd0ea0d54df6ead73069b5cdb73f303763476793138083a714ad | 45fd4ec972d661effdc2a9ea1173f4e18b02fc9d160cb332432577e03cbcedac | null | [] | 258 |
2.3 | ntnput | 3.0.5 | Minimalist Python library using wraps of undocumented `Nt` functions to interact with mouse and keyboard stealthy | # ntnput
The Minimalist Python library for Windows using wraps of undocumented `Nt` functions to interact with mouse and keyboard stealthy.
# Details
This library uses syscall wraps of undocumented `NtUserInjectMouseInput` and `NtUserInjectKeyboardInput` functions from `win32u.dll` module.
It's makes keyboard and mouse interaction safe and stealth due to the bypass of Windows triggers.</br>
**NtNput** also works faster than analogues because of usage of builtin `ctypes` library allowing to interact directly with C and machine code.
You can use this library if your process blocks usage of `mouse_event`, `SendInput` or etc. WinAPI functions.</br>
## Installation
1. You can install library using pip:
```
pip install ntnput
```
2. You can download this repo, put it's folder into your project and import it using the folder name
## Usage
Library provides several functions to interact with mouse:
1. `mouse_move(x, y)` - moves mouse from current position
2. `mouse_move_to(x, y)` - moves mouse to absolute x, y position
3. `mouse_click(button <default "left">)` - clicks mouse
4. `mouse_release(button <default "left">)` - releases mouse
5. `mouse_click_and_release(button <default "left">, delay_ms <default 0.0>)` - clicks mouse, sleeps, releases
And several functions to interact with keyboard:
1. `keyboard_press(key_code)` - presses keyboard button
2. `keyboard_release(key_code)` - releases keyboard button
3. `keyboard_press_and_release(key_code, delay_ms <default 0.0>)` - presses keyboard button, sleeps, releases
You can use official [Microsoft documentation](https://learn.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes) to find keyboard key codes definitions.
| text/markdown | Xenely | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":null,"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null} | 2026-02-20T17:16:45.571489 | ntnput-3.0.5.tar.gz | 8,413 | 20/d8/2a914a0dca4a1078a97aec9b4436d0af34b71bcff811d1f1bddd9f2d71e4/ntnput-3.0.5.tar.gz | source | sdist | null | false | c5904034324d8116df976d799b11e072 | 30b34b400c82904b95260a3ca725a91eb8ee217faeddc25533485bdca34f5070 | 20d82a914a0dca4a1078a97aec9b4436d0af34b71bcff811d1f1bddd9f2d71e4 | null | [] | 207 |
2.4 | micantis | 0.1.19 | Package to simplify Micantis API usage | # Micantis API Wrapper
A lightweight Python wrapper for interacting with the Micantis API plus some helpful utilities.
Built for ease of use, fast prototyping, and clean integration into data workflows.
---
## 🚀 Features
- Authenticate and connect to the Micantis API service
- Download and parse CSV, binary, and Parquet data into pandas DataFrames
- Parquet support for efficient data storage with embedded metadata
- Filter, search, and retrieve metadata
- Utility functions to simplify common API tasks
---
## ⚠️ Important
This package is designed for authenticated Micantis customers only.
If you are not a Micantis customer, the API wrapper and utilities in this package will not work for you.
For more information on accessing the Micantis API, please contact us at info@micantis.io.
---
## 📦 Installation
```bash
pip install micantis
```
### Optional: Parquet Support
For parquet file downloads and metadata extraction, install with parquet support:
```bash
pip install micantis[parquet]
```
Or install `pyarrow` separately:
```bash
pip install pyarrow
```
---
## 💻 Examples
### Import functions
``` python
import pandas as pd
from micantis import MicantisAPI
```
### Initialize API
``` python
# Option 1 - login with username and password
service_url = 'your service url'
username = 'your username'
password = 'your password'
api = MicantisAPI(service_url=service_url, username=username, password=password)
```
``` python
# Option 2 - login in with Microsoft Entra ID
SERVICE = 'your service url'
CLIENT_ID = 'your client id'
AUTHORITY = 'https://login.microsoftonline.com/organizations'
SCOPES = ['your scopes']
api = MicantisAPI(service_url=SERVICE, client_id=CLIENT_ID, authority=AUTHORITY, scopes=SCOPES)
```
``` python
# Option 3 - Use pre-existing token (for containerized apps)
service_url = 'your service url'
token = 'your bearer token'
api = MicantisAPI(service_url=service_url, token=token)
# No need to call authenticate() when using a token
```
``` python
# Option 4 - Use environment variables (recommended for containers/CI/CD)
# Set these environment variables:
# - WORKBOOK_API_URL: your service URL
# - WORKBOOK_TOKEN: your bearer token
api = MicantisAPI() # Will automatically use environment variables
# No need to call authenticate() when using a token
```
### Authenticate API
``` api.authenticate() ```
**Note:** When using a pre-existing token (Option 3 or 4), you don't need to call `authenticate()` as the token is already configured.
### Download Data Table Summary
#### Optional parameters
- `search`: Search string (same syntax as the Micantis WebApp)
- `barcode`: Filter by barcode
- `limit`: Number of results to return (default: 500)
- `show_ignored`: Include soft-deleted files (default: `True`)
- `min_start_date`: Only return results whose test started on or after this date (ISO format)
- `max_start_date`: Only return results whose test started on or before this date (ISO format)
- `min_end_date`: Only return results whose test ended on or after this date (ISO format)
- `max_end_date`: Only return results whose test ended on or before this date (ISO format)
- `station`: Filter by test station name
- `channel`: Filter by channel
- `cell_test_name`: Filter by cell test name
- `data_kind`: Filter by data type (e.g. `"CycleTesterData"`, `"StitchedData"`, `"PotentiostatData"`, `"FileData"`)
```python
# Basic search
table = api.get_data_table(search="your search string", limit=100)
# Filter by start date range
table = api.get_data_table(min_start_date="2025-01-01", max_start_date="2025-06-01")
# Filter by end date range
table = api.get_data_table(min_end_date="2025-01-01", max_end_date="2025-06-01")
# Filter by station and data type
table = api.get_data_table(station="your station name", data_kind="CycleTesterData")
# Filter by cell test name
table = api.get_data_table(cell_test_name="your cell test name")
# Combine multiple filters
table = api.get_data_table(
min_start_date="2025-01-01",
max_start_date="2025-12-31",
data_kind="CycleTesterData",
search="your search string",
limit=100
)
```
### Download Binary Files
``` python
# Download single file
file_id = 'File ID obtained from data table, id column'
df = api.download_binary_file(id)
```
``` python
# Download many files using list of files from the table
file_id_list = table['id'].to_list()
data = []
for id in file_id_list:
df = api.download_csv_file(id)
data.append(df)
all_data = pd.concat(data)
```
### Download CSV Files
``` python
# Download single file
file_id = 'File ID obtained from data table, id column'
df = api.download_csv_file(id)
```
``` python
# Download multiple files
id_list = table['id'].to_list()
data = []
for id in id_list:
df = api.download_csv_file(id)
data.append(df)
all_data = pd.concat(data)
```
### Download Parquet Files
Download cycle tester data as Apache Parquet files for efficient analysis. Parquet files are smaller, faster, and include embedded metadata.
#### Optional parameters
- `cycle_ranges`: Filter by cycle index (see examples below)
- `test_time_start`: Filter by test time start (seconds from test start)
- `test_time_end`: Filter by test time end (seconds from test start)
- `line_number_start`: Filter by line number start
- `line_number_end`: Filter by line number end
- `include_auxiliary_data`: Include auxiliary channels like temperature (default: `True`)
- `output_path`: Custom file path (default: uses cell_data_id as filename)
- `return_type`: What to return - `'dataframe'` (default), `'path'`, or `'bytes'`
#### Return Type Options
- **`'dataframe'`** (default): Saves file and returns pandas DataFrame - best for immediate analysis
- **`'dict'`**: Saves file and returns dict with data, metadata, and cycle_summaries - best when you need metadata (requires `pyarrow`)
- **`'path'`**: Saves file and returns path string - best for large files or batch processing
- **`'bytes'`**: Returns raw bytes without saving - best for direct cloud uploads (Databricks, Azure Blob, S3)
```python
# Download and get DataFrame (default)
file_id = 'File ID obtained from data table, id column'
df = api.download_parquet_file(file_id)
```
```python
# Get data + metadata in one call
result = api.download_parquet_file(file_id, return_type='dict')
df = result['data'] # Cycle test data
metadata = result['metadata'] # Cell metadata (name, barcode, timestamps, etc.)
cycle_summaries = result['cycle_summaries'] # Per-cycle summary statistics
```
```python
# Save file and get path (memory efficient for large files)
path = api.download_parquet_file(file_id, return_type='path')
# Later, read when needed
df = pd.read_parquet(path)
```
```python
# Get raw bytes for direct cloud upload (no local file)
parquet_bytes = api.download_parquet_file(file_id, return_type='bytes')
# Upload to Azure Blob Storage
blob_client.upload_blob(name='test_data.parquet', data=parquet_bytes)
# Or read directly into DataFrame
import io
df = pd.read_parquet(io.BytesIO(parquet_bytes))
```
#### Cycle Range Filtering
Filter data by specific cycles or cycle ranges using the `cycle_ranges` parameter.
```python
# Download only cycles 1-10
df = api.download_parquet_file(
file_id,
cycle_ranges=[{"RangeStart": 1, "RangeEnd": 10}]
)
```
```python
# Download last 5 cycles
df = api.download_parquet_file(
file_id,
cycle_ranges=[{
"RangeStart": 5,
"IsStartFromBack": True,
"RangeEnd": 1,
"IsEndFromBack": True
}]
)
```
```python
# Download specific cycles (1, 5, 10, 50)
df = api.download_parquet_file(
file_id,
cycle_ranges=[
{"Single": 1},
{"Single": 5},
{"Single": 10},
{"Single": 50}
]
)
```
```python
# Download first hour of data
df = api.download_parquet_file(
file_id,
test_time_start=0,
test_time_end=3600
)
```
#### Extract Metadata from Parquet Files
Parquet files contain embedded metadata including cell info, timestamps, cycle counts, and per-cycle summaries. Extract this metadata using `unpack_parquet()` (requires `pyarrow`).
```python
# From a saved file
result = api.unpack_parquet('file.parquet')
df = result['data'] # Cycle test data
metadata = result['metadata'] # Cell metadata (name, barcode, timestamps, etc.)
cycle_summaries = result['cycle_summaries'] # Per-cycle summary statistics
```
```python
# From bytes (no file needed)
parquet_bytes = api.download_parquet_file(file_id, return_type='bytes')
result = api.unpack_parquet(parquet_bytes)
df = result['data']
metadata = result['metadata']
cycle_summaries = result['cycle_summaries']
```
```python
# Extract and save metadata as CSV files for easy viewing
result = api.unpack_parquet('file.parquet', save_metadata=True)
# Creates:
# - file_metadata.csv
# - file_cycle_summaries.csv
```
```python
# Batch processing: Download multiple files without loading into memory
file_ids = table['id'].head(10).to_list()
paths = []
for file_id in file_ids:
path = api.download_parquet_file(file_id, return_type='path')
paths.append(path)
# Later, process files one at a time (memory efficient)
for path in paths:
result = api.unpack_parquet(path)
df = result['data']
# Process df...
```
## Cells Table
### Download Cell ID Information
Retrieve a list of cell names and GUIDs from the Micantis database with flexible filtering options.
#### Optional parameters
- `search`: Search string (same syntax as the Micantis WebApp)
- `barcode`: Search for a specific barcode
- `limit`: Number of results to return (default: 500)
- `min_date`: Only return results after this date
- `max_date`: Only return results before this date
- `show_ignored`: Include soft-deleted files (default: `True`)
``` python
search = "*NPD*"
cells_df = api.get_cells_list(search=search)
cells_df.head()
```
### Download Cell Metadata
Fetch per-cell metadata and return a clean, wide-format DataFrame.
#### Parameters:
- `cell_ids`: **List[str]**
List of cell test GUIDs (**required**)
- `metadata`: **List[str] (optional)**
List of metadata **names** (e.g., `"OCV (V)"`) or **IDs**.
If omitted, all non-image metadata will be returned by default.
- `return_images`: **bool (optional)**
If `True`, includes image metadata fields. Default is `False`.
---
#### 📘 Examples
```python
# Example 1: Get all non-image metadata for a list of cells
cell_ids = cells_df["id"].to_list()
cell_metadata_df = api.get_cell_metadata(cell_ids=cell_ids)
```
```python
# Example 2: Get specific metadata fields by name
cell_metadata_df = api.get_cell_metadata(
cell_ids=cell_ids,
metadata=["Cell width", "Cell height"],
return_images=False
)
```
```python
# Merge cell metadata table with cell names to get clean dataframe
# Merge id with Cell Name (as last column)
id_to_name = dict(zip(cells_df['id'], cells_df['name']))
cells_metadata_df['cell_name'] = cells_metadata_df['id'].map(id_to_name)
cells_metadata_df.head()
```
## Specifications Table
### Download Specifications List
Retrieve specifications with their associated user properties.
```python
# Get all specifications with their user properties
specs_df = api.get_specifications_table()
specs_df.head()
```
## Test Management
### Download Test Requests List
Retrieve test request data with flexible date filtering.
#### Optional parameters
- `since`: Date string in various formats (defaults to January 1, 2020 if not provided)
- Full month names: `"May 1, 2025"`, `"January 15, 2024"`
- ISO format: `"2025-05-01"` or `"25-05-01"`
```python
# Get all test requests (defaults to since 2020-01-01)
test_requests = api.get_test_request_list()
# Get test requests since a specific date using month name
test_requests = api.get_test_request_list(since="May 1, 2024")
# Get test requests using ISO format
test_requests = api.get_test_request_list(since="2024-05-01")
```
### Download Failed Test Requests
Retrieve only failed test requests with the same date filtering options.
```python
# Get failed test requests since a specific date
failed_requests = api.get_failed_test_requests(since="January 1, 2024")
failed_requests.head()
```
### Get Individual Test Request Details
Retrieve full details for a specific test request by ID.
**New Feature:** Multiple output format options for better data analysis!
#### Format Options
- `return_format='dict'`: Raw dictionary (default, backwards compatible)
- `return_format='dataframes'`: Returns 3 DataFrames - summary, tests, and status_log ⭐ **Recommended**
- `return_format='flat'`: Single-row DataFrame with basic info
```python
# Option 1: Dictionary format (default, backwards compatible)
request_id = "your-test-request-guid"
test_details = api.get_test_request(request_id)
# Option 2: DataFrames format (recommended for analysis) ⭐
test_details = api.get_test_request(request_id, return_format='dataframes')
print(test_details['summary']) # Basic request information
print(test_details['tests']) # All requested tests
print(test_details['status_log']) # Status change history
# Option 3: Flat DataFrame (best for combining multiple requests)
test_details = api.get_test_request(request_id, return_format='flat')
```
#### Batch Processing Multiple Requests
```python
# Get summaries for multiple test requests
request_ids = test_requests['id'].head(10).to_list()
all_summaries = []
for req_id in request_ids:
summary = api.get_test_request(req_id, return_format='flat')
all_summaries.append(summary)
# Combine into single DataFrame
combined_df = pd.concat(all_summaries, ignore_index=True)
print(f"Retrieved {len(combined_df)} test requests")
combined_df.head()
```
## Write Cell Metadata
Micantis lets you programmatically assign or update metadata for each cell using either:
- the human-readable field name (e.g., "Technician", "Weight (g)")
- or the internal propertyDefinitionId (UUID)
#### 📘 Examples
```python
# Example 1: Update the technician field for a cell
changes = [
{
"id": "your-cell-test-guid-here", # cell test GUID
"field": "Technician",
"value": "Mykela"
},
{
"id": "your-cell-test-guid-here",
"field": "Weight (g)",
"value": 98.7
}
]
api.write_cell_metadata(changes=changes)
# Verify the changes
api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
```
```python
# Example 2: Update using propertyDefinitionId (advanced)
changes = [
{
"id": "your-cell-test-guid-here",
"propertyDefinitionId": "your-property-definition-guid",
"value": 98.7
}
]
api.write_cell_metadata(changes=changes)
# Verify the changes
api.get_cell_metadata(cell_ids=["your-cell-test-guid-here"], metadata=['Weight (g)', 'Technician'])
```
## Stitch Data
Combine multiple data sets into a single stitched data set. This is useful for creating continuous test data from multiple separate test runs.
#### Parameters
- `name`: **str (required)**
Name for the stitched data set
- `cell_data_ids`: **List[str] (required)**
List of cell data GUIDs to stitch together
- `increment_cycle_number`: **bool (optional)**
Whether to increment cycle numbers when stitching. Default is `False`.
- `advanced_mode`: **bool (optional)**
Advanced mode for manual ordering of data sets. Default is `False`.
- `archive_source_data`: **bool (optional)**
Archive (soft delete) the source data sets after stitching. Default is `False`.
- `id`: **str (optional)**
Optional ID for updating an existing stitched data set. Leave `None` to create new.
- `allow_async`: **bool (optional)**
If `True`, runs asynchronously and returns job ID. If `False`, waits for completion. Default is `False`.
#### Returns
- If `allow_async=False`: Dictionary with `'stitched_data_id'`
- If `allow_async=True`: Dictionary with `'job_id'`
#### 📘 Examples
```python
# Example 1: Stitch multiple test runs together
cell_data_ids = ["guid1", "guid2", "guid3"]
result = api.stitch_data(
name="Combined Test Data",
cell_data_ids=cell_data_ids,
increment_cycle_number=True
)
print(f"Stitched data ID: {result['stitched_data_id']}")
```
```python
# Example 2: Stitch and archive source data
result = api.stitch_data(
name="Complete Test Sequence",
cell_data_ids=cell_data_ids,
increment_cycle_number=True,
archive_source_data=True # Source files will be soft-deleted
)
# Download the stitched result
stitched_df = api.download_parquet_file(result['stitched_data_id'])
```
```python
# Example 3: Async mode for large data sets
result = api.stitch_data(
name="Large Combined Dataset",
cell_data_ids=large_cell_data_list,
allow_async=True
)
print(f"Job ID: {result['job_id']}")
# Check job status via the Micantis WebApp or use the job API
```
## Archive Data
Archive (soft delete) data sets. Archived data is hidden from the default list view but not permanently deleted and can be unarchived.
**Note:** The `archive_data()` method toggles the archive status - calling it on an archived file will unarchive it.
#### Parameters
- `cell_data_id`: **str (required)**
Cell data GUID to archive/unarchive
#### Returns
- Dictionary with `'id'` and `'archived'` (bool indicating new state)
#### 📘 Examples
```python
# Example 1: Archive a single data set
result = api.archive_data(cell_data_id="your-guid-here")
print(f"File archived: {result['archived']}") # True if now archived
```
```python
# Example 2: Archive multiple data sets
cell_data_ids = ["guid1", "guid2", "guid3"]
for cell_id in cell_data_ids:
result = api.archive_data(cell_id)
print(f"Archived {cell_id}: {result['archived']}")
```
```python
# Example 3: Unarchive by calling again
result = api.archive_data(cell_data_id="your-guid-here")
print(f"File archived: {result['archived']}") # False if now unarchived
```
```python
# Example 4: Combined workflow - stitch and archive
# Stitch data with automatic archiving
result = api.stitch_data(
name="Combined Data",
cell_data_ids=cell_ids,
archive_source_data=True # Automatically archives source files
)
# Or manually archive after stitching
result = api.stitch_data(name="Combined Data", cell_data_ids=cell_ids)
for cell_id in cell_ids:
api.archive_data(cell_id)
```
| text/markdown | null | Mykela DeLuca <mykela.deluca@micantis.io> | null | null | null | null | [] | [] | null | null | >=3.7 | [] | [] | [] | [
"requests",
"pandas",
"msal",
"azure-identity",
"pyarrow>=16.0.0; extra == \"parquet\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.9.20 | 2026-02-20T17:16:23.369032 | micantis-0.1.19.tar.gz | 25,001 | 3c/ad/beda2bbf41a86413df030483e02198a08e3c9967a8008b308b81e53db1bd/micantis-0.1.19.tar.gz | source | sdist | null | false | 446012795b043495468adc1de869dd8a | ee3c54240c2e620c845facb91493d9583e2fa6d64002b6e55e513de22f7ed66f | 3cadbeda2bbf41a86413df030483e02198a08e3c9967a8008b308b81e53db1bd | MIT | [
"LICENSE"
] | 256 |
2.4 | sae-lens | 6.37.3 | Training and Analyzing Sparse Autoencoders (SAEs) | <img width="1308" height="532" alt="saes_pic" src="https://github.com/user-attachments/assets/2a5d752f-b261-4ee4-ad5d-ebf282321371" />
# SAE Lens
[](https://pypi.org/project/sae-lens/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/decoderesearch/SAELens/actions/workflows/build.yml)
[](https://github.com/decoderesearch/SAELens/actions/workflows/deploy_docs.yml)
[](https://codecov.io/gh/decoderesearch/SAELens)
SAELens exists to help researchers:
- Train sparse autoencoders.
- Analyse sparse autoencoders / research mechanistic interpretability.
- Generate insights which make it easier to create safe and aligned AI systems.
SAELens inference works with any PyTorch-based model, not just TransformerLens. While we provide deep integration with TransformerLens via `HookedSAETransformer`, SAEs can be used with Hugging Face Transformers, NNsight, or any other framework by extracting activations and passing them to the SAE's `encode()` and `decode()` methods.
Please refer to the [documentation](https://decoderesearch.github.io/SAELens/) for information on how to:
- Download and Analyse pre-trained sparse autoencoders.
- Train your own sparse autoencoders.
- Generate feature dashboards with the [SAE-Vis Library](https://github.com/callummcdougall/sae_vis/tree/main).
SAE Lens is the result of many contributors working collectively to improve humanity's understanding of neural networks, many of whom are motivated by a desire to [safeguard humanity from risks posed by artificial intelligence](https://80000hours.org/problem-profiles/artificial-intelligence/).
This library is maintained by [Joseph Bloom](https://www.decoderesearch.com/), [Curt Tigges](https://curttigges.com/), [Anthony Duong](https://github.com/anthonyduong9) and [David Chanin](https://github.com/chanind).
## Loading Pre-trained SAEs.
Pre-trained SAEs for various models can be imported via SAE Lens. See this [page](https://decoderesearch.github.io/SAELens/pretrained_saes/) for a list of all SAEs.
## Migrating to SAELens v6
The new v6 update is a major refactor to SAELens and changes the way training code is structured. Check out the [migration guide](https://decoderesearch.github.io/SAELens/latest/migrating/) for more details.
## Tutorials
- [SAE Lens + Neuronpedia](tutorials/tutorial_2_0.ipynb)[](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/tutorial_2_0.ipynb)
- [Loading and Analysing Pre-Trained Sparse Autoencoders](tutorials/basic_loading_and_analysing.ipynb)
[](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/basic_loading_and_analysing.ipynb)
- [Understanding SAE Features with the Logit Lens](tutorials/logits_lens_with_features.ipynb)
[](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/logits_lens_with_features.ipynb)
- [Training a Sparse Autoencoder](tutorials/training_a_sparse_autoencoder.ipynb)
[](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/training_a_sparse_autoencoder.ipynb)
- [Training SAEs on Synthetic Data](tutorials/training_saes_on_synthetic_data.ipynb)
[](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/training_saes_on_synthetic_data.ipynb)
- [SynthSAEBench: Evaluating SAE Architectures on Synthetic Data](tutorials/synth_sae_bench.ipynb)
[](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/synth_sae_bench.ipynb)
## Join the Slack!
Feel free to join the [Open Source Mechanistic Interpretability Slack](https://join.slack.com/t/opensourcemechanistic/shared_invite/zt-375zalm04-GFd5tdBU1yLKlu_T_JSqZQ) for support!
## Other SAE Projects
- [dictionary-learning](https://github.com/saprmarks/dictionary_learning): An SAE training library that focuses on having hackable code.
- [Sparsify](https://github.com/EleutherAI/sparsify): A lean SAE training library focused on TopK SAEs.
- [Overcomplete](https://github.com/KempnerInstitute/overcomplete): SAE training library focused on vision models.
- [SAE-Vis](https://github.com/callummcdougall/sae_vis): A library for visualizing SAE features, works with SAELens.
- [SAEBench](https://github.com/adamkarvonen/SAEBench): A suite of LLM SAE benchmarks, works with SAELens.
## Citation
Please cite the package as follows:
```
@misc{bloom2024saetrainingcodebase,
title = {SAELens},
author = {Bloom, Joseph and Tigges, Curt and Duong, Anthony and Chanin, David},
year = {2024},
howpublished = {\url{https://github.com/decoderesearch/SAELens}},
}
```
| text/markdown | Joseph Bloom | null | null | null | MIT | deep-learning, sparse-autoencoders, mechanistic-interpretability, PyTorch | [
"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",
"Programming Language :: Python :: 3.14",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"babe<0.0.8,>=0.0.7",
"datasets>=3.1.0",
"mamba-lens<0.0.5,>=0.0.4; extra == \"mamba\"",
"nltk<4.0.0,>=3.8.1",
"plotly>=5.19.0",
"plotly-express>=0.4.1",
"python-dotenv>=1.0.1",
"pyyaml<7.0.0,>=6.0.1",
"safetensors<1.0.0,>=0.4.2",
"simple-parsing<0.2.0,>=0.1.6",
"tenacity>=9.0.0",
"transformer-lens>=2.16.1",
"transformers<6.0.0,>=4.38.1",
"typing-extensions<5.0.0,>=4.10.0"
] | [] | [] | [] | [
"Homepage, https://decoderesearch.github.io/SAELens",
"Repository, https://github.com/decoderesearch/SAELens"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:15:45.894792 | sae_lens-6.37.3.tar.gz | 254,339 | a3/94/e9f44ce182a7e474b4b33c80022fdcb24a16889fe11a868997eb09f6754f/sae_lens-6.37.3.tar.gz | source | sdist | null | false | de3b16525f1baeb2293014fd892bb7fe | bbdbaeef1a384b71098bc36caecd1f1d18bc1e6c6fa3baa47ad33bc832683030 | a394e9f44ce182a7e474b4b33c80022fdcb24a16889fe11a868997eb09f6754f | null | [
"LICENSE"
] | 730 |
2.4 | pydynox | 0.27.0 | A fast DynamoDB ORM for Python with a Rust core | # pydynox 🐍⚙️
[](https://github.com/ferrumio/pydynox/actions/workflows/main.yml)
[](https://pypi.org/project/pydynox/)
[](https://pypi.org/project/pydynox/)
[](https://github.com/ferrumio/pydynox/blob/main/LICENSE)
[](https://pepy.tech/project/pydynox)
[](https://securityscorecards.dev/viewer/?uri=github.com/ferrumio/pydynox)
A fast, async-first DynamoDB ORM for Python with a Rust core.
> 📢 **1.0 Release: March 2-6, 2026** - The API is stable and fully async. We're collecting feedback before the official release. Try it out and let us know what you think!
## Why pydynox?
**Py**(thon) + **Dyn**(amoDB) + **Ox**(ide/Rust)
## Key features
- **Async-first** - Async by default, sync with `sync_` prefix. True non-blocking I/O with Rust's tokio
- **Fast** - Rust core for serialization, compression, and encryption. Zero Python runtime dependencies
- **Simple API** - Class-based models like PynamoDB. Define once, use everywhere
- **Type-safe** - Full type hints for IDE autocomplete and type checkers
- **Pydantic support** - Use your existing Pydantic models with DynamoDB
- **Batteries included** - TTL, hooks, auto-generate, optimistic locking, rate limiting, encryption, compression, S3 attributes, PartiQL, observability
## Installation
```bash
pip install pydynox
```
Optional extras:
```bash
pip install pydynox[pydantic] # Pydantic integration
pip install pydynox[opentelemetry] # OpenTelemetry tracing
```
## Quick start
### Define a model
```python
from pydynox import Model, ModelConfig
from pydynox.attributes import StringAttribute, NumberAttribute
class User(Model):
model_config = ModelConfig(table="users")
pk = StringAttribute(partition_key=True)
sk = StringAttribute(sort_key=True)
name = StringAttribute()
age = NumberAttribute(default=0)
```
### Async operations (default)
Async methods have no prefix. This is the default.
```python
import asyncio
async def main():
# Create
user = User(pk="USER#123", sk="PROFILE", name="John")
await user.save()
# Read
user = await User.get(pk="USER#123", sk="PROFILE")
# Update
await user.update(name="Jane", age=30)
# Query
async for user in User.query(partition_key="USER#123"):
print(user.name)
# Delete
await user.delete()
asyncio.run(main())
```
### Sync operations (use sync_ prefix)
For scripts, CLI tools, or code that doesn't need async.
```python
# Create
user = User(pk="USER#123", sk="PROFILE", name="John")
user.sync_save()
# Read
user = User.sync_get(pk="USER#123", sk="PROFILE")
# Update
user.sync_update(name="Jane", age=30)
# Query
for user in User.sync_query(partition_key="USER#123"):
print(user.name)
# Delete
user.sync_delete()
```
## Async-first API
pydynox is async-first. Methods without prefix are async, methods with `sync_` prefix are sync.
| Async (default) | Sync |
|-----------------|------|
| `await model.save()` | `model.sync_save()` |
| `await model.delete()` | `model.sync_delete()` |
| `await model.update()` | `model.sync_update()` |
| `await Model.get()` | `Model.sync_get()` |
| `async for x in Model.query()` | `for x in Model.sync_query()` |
| `async for x in Model.scan()` | `for x in Model.sync_scan()` |
| `await Model.batch_get()` | `Model.sync_batch_get()` |
| `async with BatchWriter()` | `with SyncBatchWriter()` |
Why async? Python's GIL blocks threads during I/O. With async, your app can handle other work while waiting for DynamoDB. pydynox releases the GIL during network calls, so async operations are truly non-blocking.
## Conditions
```python
# Save only if item doesn't exist
await user.save(condition=User.pk.not_exists())
# Delete with condition
await user.delete(condition=User.version == 5)
# Combine with & (AND) and | (OR)
await user.save(condition=User.pk.not_exists() | (User.version == 1))
```
## Atomic updates
```python
# Increment
await user.update(atomic=[User.age.add(1)])
# Append to list
await user.update(atomic=[User.tags.append(["verified"])])
# Multiple operations
await user.update(atomic=[
User.age.add(1),
User.tags.append(["premium"]),
])
```
## Batch operations
```python
from pydynox import BatchWriter, SyncBatchWriter, DynamoDBClient
client = DynamoDBClient()
# Async (default)
async with BatchWriter(client, "users") as batch:
for i in range(100):
batch.put({"pk": f"USER#{i}", "sk": "PROFILE", "name": f"User {i}"})
# Sync
with SyncBatchWriter(client, "users") as batch:
batch.put({"pk": "USER#1", "sk": "PROFILE", "name": "John"})
```
## Global Secondary Index
```python
from pydynox.indexes import GlobalSecondaryIndex
class User(Model):
model_config = ModelConfig(table="users")
pk = StringAttribute(partition_key=True)
email = StringAttribute()
email_index = GlobalSecondaryIndex(
index_name="email-index",
partition_key="email",
)
# Async
async for user in User.email_index.query(partition_key="john@test.com"):
print(user.name)
# Sync
for user in User.email_index.sync_query(partition_key="john@test.com"):
print(user.name)
```
## Transactions
```python
from pydynox import DynamoDBClient, Transaction
client = DynamoDBClient()
async with Transaction(client) as tx:
tx.put("users", {"pk": "USER#1", "sk": "PROFILE", "name": "John"})
tx.put("orders", {"pk": "ORDER#1", "sk": "DETAILS", "user": "USER#1"})
```
## Pydantic integration
```python
from pydantic import BaseModel, EmailStr
from pydynox import DynamoDBClient
from pydynox.integrations.pydantic import dynamodb_model
client = DynamoDBClient()
@dynamodb_model(table="users", partition_key="pk", sort_key="sk", client=client)
class User(BaseModel):
pk: str
sk: str
name: str
email: EmailStr
# Async (default)
user = User(pk="USER#123", sk="PROFILE", name="John", email="john@test.com")
await user.save()
user = await User.get(pk="USER#123", sk="PROFILE")
# Sync
user.sync_save()
user = User.sync_get(pk="USER#123", sk="PROFILE")
```
## S3 attribute (large files)
DynamoDB has a 400KB item limit. `S3Attribute` stores files in S3 and keeps metadata in DynamoDB.
```python
from pydynox.attributes import S3Attribute, S3File
class Document(Model):
model_config = ModelConfig(table="documents")
pk = StringAttribute(partition_key=True)
content = S3Attribute(bucket="my-bucket", prefix="docs/")
# Upload
doc = Document(pk="DOC#1")
doc.content = S3File(b"...", name="report.pdf", content_type="application/pdf")
await doc.save()
# Download (async)
data = await doc.content.get_bytes()
await doc.content.save_to("/path/to/file.pdf")
url = await doc.content.presigned_url(3600)
# Download (sync)
data = doc.content.sync_get_bytes()
doc.content.sync_save_to("/path/to/file.pdf")
```
## Table management
```python
# Async (default)
await User.create_table(wait=True)
if await User.table_exists():
print("Table exists")
# Sync
User.sync_create_table(wait=True)
if User.sync_table_exists():
print("Table exists")
```
## GenAI contributions 🤖
I believe GenAI is transforming how we build software. It's a powerful tool that accelerates development when used by developers who understand what they're doing.
To support both humans and AI agents, I created:
- `.ai/` folder - Guidelines for agentic IDEs (Cursor, Windsurf, Kiro, etc.)
- `ADR/` folder - Architecture Decision Records for humans to understand the "why" behind decisions
**If you're contributing with AI help:**
- Understand what the AI generated before submitting
- Make sure the code follows the project patterns
- Test your changes
I reserve the right to reject low-quality PRs where project patterns are not followed and it's clear that GenAI was driving instead of the developer.
## Documentation
Full documentation: [https://ferrumio.github.io/pydynox](https://ferrumio.github.io/pydynox)
## License
Apache 2.0 License
## Inspirations
- [PynamoDB](https://github.com/pynamodb/PynamoDB) - The ORM-style API and model design
- [Pydantic](https://github.com/pydantic/pydantic) - Data validation patterns
- [dynarust](https://github.com/Anexen/dynarust) - Rust DynamoDB client patterns
- [dyntastic](https://github.com/nayaverdier/dyntastic) - Pydantic + DynamoDB integration ideas
## Building from source
```bash
# Clone
git clone https://github.com/ferrumio/pydynox.git
cd pydynox
# Build (requires Python 3.11+, Rust 1.70+)
pip install maturin
maturin develop
# Test
pip install -e ".[dev]"
pytest
```
| text/markdown; charset=UTF-8; variant=GFM | null | Leandro Cavalcante Damascena <leandro.damascena@gmail.com> | null | null | Apache-2.0 | dynamodb, orm, aws, rust, python | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Programming Language :: Rust",
"Topic :: Database"
] | [] | https://github.com/ferrumio/pydynox | null | >=3.11 | [] | [] | [] | [
"opentelemetry-api>=1.0; extra == \"opentelemetry\"",
"pydantic>=2.0; extra == \"pydantic\""
] | [] | [] | [] | [
"Documentation, https://ferrumio.github.io/pydynox",
"Homepage, https://github.com/ferrumio/pydynox",
"Repository, https://github.com/ferrumio/pydynox"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T17:15:22.777816 | pydynox-0.27.0.tar.gz | 537,641 | 90/36/d755c0d28fcbe7731ddfa7f48b9259eb1cdcbf393c6609cb534d31e905d7/pydynox-0.27.0.tar.gz | source | sdist | null | false | 1518f2262c84d20034153baf99beff80 | c18eca142af0c0f9577693134e3cb7bcf0bdb4dd6e9a9dcb0e68440554416676 | 9036d755c0d28fcbe7731ddfa7f48b9259eb1cdcbf393c6609cb534d31e905d7 | null | [
"LICENSE"
] | 1,026 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.