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 | allegro-cli | 0.2.0 | CLI for browsing Allegro offers, managing cart, and tracking packages — human-readable and LLM-agent friendly | # allegro-cli
[](https://github.com/pkonowrocki/allegro-cli/actions/workflows/ci.yml)
CLI for browsing [Allegro](https://allegro.pl) offers, managing your cart, and tracking packages. Designed to be both human-readable and LLM-agent friendly.
All output is available as aligned text tables, JSON, or TSV — pick what suits your workflow or pipe it into other tools.
## Install
**From GitHub Releases** (recommended):
```bash
pip install https://github.com/pkonowrocki/allegro-cli/releases/latest/download/allegro_cli-0.1.0-py3-none-any.whl
```
**From source (latest)**:
```bash
pip install git+https://github.com/pkonowrocki/allegro-cli.git
```
**For development**:
```bash
git clone https://github.com/pkonowrocki/allegro-cli.git
cd allegro-cli
pip install -e ".[dev]"
```
## Setup
Import cookies from your browser:
```bash
allegro login
```
Paste cookies from Chrome DevTools (Application > Cookies > allegro.pl). Both the DevTools table format and raw cookie header strings are accepted.
Alternatively, set cookies directly:
```bash
allegro config set --cookies 'cookie1=value1; cookie2=value2'
```
## Usage
### Search
```bash
allegro search "laptop"
allegro search "laptop" --category 491
allegro search "laptop" --category laptopy-491 --sort pd --price-min 2000 --price-max 5000
allegro search "laptop" --columns "id,name,sellingMode.price.amount,parameters"
```
| Flag | Description |
|------|-------------|
| `--category` | Category ID or slug (e.g. `491`, `laptopy-491`) |
| `--sort` | Sort order: `p` (price asc), `pd` (price desc), `m` (relevance), `n` (newest) |
| `--price-min` | Minimum price in PLN |
| `--price-max` | Maximum price in PLN |
| `--page` | Page number (default: 1) |
| `--columns` | Comma-separated columns to display |
### Offer details
```bash
allegro offer 12345678
allegro offer 12345678 --columns "name,sellingMode.price.amount,parameters"
```
Offer pages include a `parameters` field with product specifications (e.g. processor, RAM, screen size) extracted automatically from the listing.
### Cart
```bash
allegro cart list
allegro cart add OFFER_ID SELLER_ID --quantity 2
allegro cart remove OFFER_ID SELLER_ID
```
### Packages
```bash
allegro packages
```
### Configuration
```bash
allegro config show
allegro config set --output-format json
allegro config set --flaresolverr-url http://localhost:8191/v1
```
## Output formats
All commands support `--format text` (default), `--format json`, and `--format tsv`.
```bash
allegro search "laptop" --format json # full JSON array
allegro search "laptop" --format tsv # tab-separated, pipe-friendly
allegro search "laptop" # aligned text table (default)
allegro offer 12345678 --format json # full offer with parameters
```
Use `--columns` to select specific fields (dot-notation supported):
```bash
allegro search "laptop" --columns "id,name,sellingMode.price.amount"
allegro offer 12345678 --columns "name,parameters"
```
Set a persistent default:
```bash
allegro config set --output-format json
```
## Anti-bot handling
Allegro uses anti-bot protection (DataDome). The CLI first tries a direct request with your cookies via `curl_cffi` (Chrome TLS fingerprint). If that gets a 403, it falls back to [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr):
```bash
docker run -d --name flaresolverr -p 8191:8191 ghcr.io/flaresolverr/flaresolverr:latest
```
## Development
```bash
pip install -e ".[dev]"
pytest
```
| text/markdown | Piotr Konowrocki | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"httpx>=0.27",
"beautifulsoup4>=4.12",
"lxml>=5.0",
"curl_cffi>=0.7",
"pytest>=8.0; extra == \"dev\"",
"commitizen>=4.1; extra == \"dev\"",
"build>=1.0; extra == \"dev\""
] | [] | [] | [] | [
"Repository, https://github.com/pkonowrocki/allegro-cli"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:29:00.076868 | allegro_cli-0.2.0.tar.gz | 25,014 | 65/09/31e3cade246d27098853e1cdab968f3b8566aaa9994f712be76f027c128f/allegro_cli-0.2.0.tar.gz | source | sdist | null | false | 6d1605141a6bc1116f5e42d3b1fc7d5b | 021e77782fedcabba76cb57e2688b04b2046fd15ddb2ef9206a4779cfe0935be | 650931e3cade246d27098853e1cdab968f3b8566aaa9994f712be76f027c128f | null | [] | 212 |
2.4 | tesseract-core | 1.4.0 | A toolkit for universal, autodiff-native software components. | <picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/pasteurlabs/tesseract-core/blob/main/docs/static/logo-dark.png" width="128" align="right">
<img alt="" src="https://github.com/pasteurlabs/tesseract-core/blob/main/docs/static/logo-light.png" width="128" align="right">
</picture>
### Tesseract Core
Universal, autodiff-native software components for Simulation Intelligence. :package:
[Read the docs](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/) |
[Report an issue](https://github.com/pasteurlabs/tesseract-core/issues) |
[Talk to the community](https://si-tesseract.discourse.group/) |
[Contribute](https://github.com/pasteurlabs/tesseract-core/blob/main/CONTRIBUTING.md)
---
[](https://doi.org/10.21105/joss.08385)
**Tesseract Core** bundles:
1. Tools to define, create, and run Tesseracts, via the `tesseract` CLI and `tesseract_core` Python API.
2. The Tesseract Runtime, a lightweight, high-performance execution environment for Tesseracts.
## What is a Tesseract?
Tesseracts are components that expose experimental, research-grade software to the world. They are self-contained, self-documenting, and self-executing, via command line and HTTP. They are designed to be easy to create, easy to use, and easy to share, including in a production environment. This repository contains all you need to define your own and execute them.
Tesseracts provide built-in support for [differentiable programming](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/content/introduction/differentiable-programming.html) by propagating gradient information at the level of individual components, making it easy to build complex, diverse software pipelines that can be optimized end-to-end.
## Quick start
> [!NOTE]
> Before proceeding, make sure you have a [working installation of Docker](https://docs.docker.com/engine/install/) and a modern Python installation (Python 3.10+); if you prefer Docker Desktop for your platform, see [our extended installation instructions](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/content/introduction/installation.html#basic-installation).
1. Install Tesseract Core:
```bash
$ pip install tesseract-core
```
2. Build an example Tesseract:
```bash
$ git clone https://github.com/pasteurlabs/tesseract-core
$ tesseract build tesseract-core/examples/vectoradd
```
3. Display its API documentation:
```bash
$ tesseract apidoc vectoradd
```
<p align="center">
<img src="https://github.com/pasteurlabs/tesseract-core/blob/main/docs/img/apidoc-screenshot.png" width="600">
</p>
4. Run the Tesseract:
```bash
$ tesseract run vectoradd apply '{"inputs": {"a": [1], "b": [2]}}'
{"result":{"object_type":"array","shape":[1],"dtype":"float64","data":{"buffer":[3.0],"encoding":"json"}}}⏎
```
> [!TIP]
> Now you're ready to dive into the [documentation](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/) for more information on
> [installation](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/content/introduction/installation.html),
> [creating Tesseracts](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/content/creating-tesseracts/create.html), and
> [invoking them](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/content/using-tesseracts/use.html).
## License
Tesseract Core is licensed under the [Apache License 2.0](https://github.com/pasteurlabs/tesseract-core/blob/main/LICENSE) and is free to use, modify, and distribute (under the terms of the license).
Tesseract is a registered trademark of Pasteur Labs, Inc. and may not be used without permission.
| text/markdown | null | "The Tesseract team @ Pasteur Labs + OSS contributors" <info@simulation.science> | null | null | Apache-2.0 | null | [] | [] | null | null | <3.14,>=3.10 | [] | [] | [] | [
"jinja2",
"numpy",
"pip",
"pydantic",
"pyyaml",
"requests>=2.32.4",
"rich",
"typer",
"aiobotocore>=2.19.0; extra == \"dev\"",
"autodoc-pydantic; extra == \"dev\"",
"click<=8.3.1,>=8.1; extra == \"dev\"",
"debugpy<=1.8.20,>=1.8.14; extra == \"dev\"",
"docker; extra == \"dev\"",
"fastapi; extra == \"dev\"",
"fastapi<=0.128.5,>=0.115; extra == \"dev\"",
"fsspec[http,s3]<=2026.2.0,>=2024.12; extra == \"dev\"",
"furo; extra == \"dev\"",
"httpx; extra == \"dev\"",
"jsf; extra == \"dev\"",
"mlflow-skinny<=3.9.0,>=3.7.0; extra == \"dev\"",
"moto[server]; extra == \"dev\"",
"myst-nb; extra == \"dev\"",
"numpy; extra == \"dev\"",
"numpy<=2.4.2,>=1.26; extra == \"dev\"",
"pre-commit; extra == \"dev\"",
"pybase64<=1.4.3,>=1.4; extra == \"dev\"",
"pydantic<=2.12.5,>=2.10; extra == \"dev\"",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest-mock; extra == \"dev\"",
"requests<=2.32.5,>=2.32.4; extra == \"dev\"",
"sphinx; extra == \"dev\"",
"sphinx-autodoc-typehints; extra == \"dev\"",
"sphinx-click; extra == \"dev\"",
"sphinx-copybutton; extra == \"dev\"",
"sphinx-design; extra == \"dev\"",
"sphinxext-opengraph; extra == \"dev\"",
"typeguard; extra == \"dev\"",
"typer<=0.21.1,>=0.15; extra == \"dev\"",
"uvicorn<=0.40.0,>=0.34; extra == \"dev\"",
"autodoc-pydantic; extra == \"docs\"",
"click<=8.3.1,>=8.1; extra == \"docs\"",
"debugpy<=1.8.20,>=1.8.14; extra == \"docs\"",
"fastapi<=0.128.5,>=0.115; extra == \"docs\"",
"fsspec[http,s3]<=2026.2.0,>=2024.12; extra == \"docs\"",
"furo; extra == \"docs\"",
"mlflow-skinny<=3.9.0,>=3.7.0; extra == \"docs\"",
"myst-nb; extra == \"docs\"",
"numpy<=2.4.2,>=1.26; extra == \"docs\"",
"pybase64<=1.4.3,>=1.4; extra == \"docs\"",
"pydantic<=2.12.5,>=2.10; extra == \"docs\"",
"requests<=2.32.5,>=2.32.4; extra == \"docs\"",
"sphinx; extra == \"docs\"",
"sphinx-autodoc-typehints; extra == \"docs\"",
"sphinx-click; extra == \"docs\"",
"sphinx-copybutton; extra == \"docs\"",
"sphinx-design; extra == \"docs\"",
"sphinxext-opengraph; extra == \"docs\"",
"typer<=0.21.1,>=0.15; extra == \"docs\"",
"uvicorn<=0.40.0,>=0.34; extra == \"docs\"",
"click<=8.3.1,>=8.1; extra == \"runtime\"",
"debugpy<=1.8.20,>=1.8.14; extra == \"runtime\"",
"fastapi<=0.128.5,>=0.115; extra == \"runtime\"",
"fsspec[http,s3]<=2026.2.0,>=2024.12; extra == \"runtime\"",
"mlflow-skinny<=3.9.0,>=3.7.0; extra == \"runtime\"",
"numpy<=2.4.2,>=1.26; extra == \"runtime\"",
"pybase64<=1.4.3,>=1.4; extra == \"runtime\"",
"pydantic<=2.12.5,>=2.10; extra == \"runtime\"",
"requests<=2.32.5,>=2.32.4; extra == \"runtime\"",
"typer<=0.21.1,>=0.15; extra == \"runtime\"",
"uvicorn<=0.40.0,>=0.34; extra == \"runtime\""
] | [] | [] | [] | [
"Homepage, https://github.com/pasteurlabs/tesseract-core",
"Documentation, https://docs.pasteurlabs.ai/projects/tesseract-core/latest"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:28:17.303255 | tesseract_core-1.4.0.tar.gz | 38,746,590 | 26/df/03746e1d7c5b4b9afbba60dcbdde86eb21658af0e0390cda58feb9488351/tesseract_core-1.4.0.tar.gz | source | sdist | null | false | ce2a8209447e41fc09e8a423e61b6042 | 82ae7a473b80663117f47667d335a4d1d1fcc65f6b79d4ca2e57ca5ea42cd75b | 26df03746e1d7c5b4b9afbba60dcbdde86eb21658af0e0390cda58feb9488351 | null | [
"LICENSE"
] | 250 |
2.4 | suprsend-py-sdk | 0.17.0 | Suprsend library for Python | # suprsend-py-sdk
This package can be included in a python3 project to easily integrate
with `SuprSend` platform.
### Installation
`suprsend-py-sdk` is available on PyPI. You can install using pip.
```bash
pip install suprsend-py-sdk
```
This SDK depends on a system package called `libmagic`. You can install it as follows:
```bash
# On debian based systems
sudo apt install libmagic
# If you are using macOS
brew install libmagic
```
### Usage
Initialize the SuprSend SDK
```python3
from suprsend import Suprsend
# Initialize SDK
supr_client = Suprsend("workspace_key", "workspace_secret")
```
Following example shows a sample request for triggering a workflow.
It triggers a pre-created workflow `purchase-made` to a recipient with id: `distinct_id`,
email: `user@example.com` & androidpush(fcm-token): `__android_push_fcm_token__`
```python3
from suprsend import WorkflowTriggerRequest
# Prepare Workflow body
wf = WorkflowTriggerRequest(
body={
"workflow": "purchase-made",
"recipients": [
{
"distinct_id": "0f988f74-6982-41c5-8752-facb6911fb08",
# if $channels is present, communication will be tried on mentioned channels only (for this request).
# "$channels": ["email"],
"$email": ["user@example.com"],
"$androidpush": [{"token": "__android_push_token__", "provider": "fcm", "device_id": ""}],
}
],
# data can be any json / serializable python-dictionary
"data": {
"first_name": "User",
"spend_amount": "$10",
"nested_key_example": {
"nested_key1": "some_value_1",
"nested_key2": {
"nested_key3": "some_value_3",
},
}
}
}
)
# Trigger workflow
response = supr_client.workflows.trigger(wf)
print(response)
```
When you call `supr_client.workflows.trigger`, the SDK internally makes an HTTP call to SuprSend
Platform to register this request, and you'll immediately receive a response indicating
the acceptance status.
You can also pass `idempotency-key` while triggering a workflow. Maximum length of idempotency_key can be 64 chars.
idempotency_key has multiple uses e.g.
1. Avoid duplicate request. If Suprsend receives and processes a request with an idempotency_key,
it will skip processing requests with same idempotency_key for next 24 hours.
2. You can use this key to track webhooks related to workflow notifications.
```python3
from suprsend import WorkflowTriggerRequest
workflow_body = {...}
wf = WorkflowTriggerRequest(body=workflow_body, idempotency_key="__uniq_request_id__")
# You can also pass the tenant_id on behalf of which the workflow is to run.
wf = WorkflowTriggerRequest(body=workflow_body, idempotency_key="__uniq_request_id__", tenant_id="default")
# Trigger workflow
response = supr_client.workflows.trigger(wf)
print(response)
```
Note: The actual processing/execution of workflow happens asynchronously.
```python
# If the call succeeds, response will looks like:
{
"success": True,
"status": "success",
"status_code": 202,
"message": "Message received",
}
# In case the call fails. You will receive a response with success=False
{
"success": False,
"status": "fail",
"status_code": 400/500,
"message": "error message",
}
```
### Add attachments
To add one or more Attachments to a Workflow/Notification (viz. Email),
call `WorkflowTriggerRequest.add_attachment(file_path)`.
If providing a local path, ensure that it is proper, otherwise it will raise FileNotFoundError.
```python
from suprsend import WorkflowTriggerRequest
workflow_body = {...}
wf_instance = WorkflowTriggerRequest(body=workflow_body)
# this snippet can be used to add attachment to workflow.
file_path = "/home/user/billing.pdf"
wf_instance.add_attachment(file_path)
```
#### Attachment structure
The `add_attachment(...)` call appends below structure to `body->data->'$attachments'`
```json
{
"filename": "billing.pdf",
"contentType": "application/pdf",
"data": "Q29uZ3JhdHVsYXRpb25zLCB5b3UgY2FuIGJhc2U2NCBkZWNvZGUh",
}
```
Where
* `filename` - name of file.
* `contentType` - MIME-type of file content.
* `data` - base64-encoded content of file.
### Limitation
* a single workflow body size must not exceed 800KB (800 * 1024 bytes).
* if size exceeds above mentioned limit, SDK raises python's builtin ValueError.
### Bulk API for Workflow Requests
You can send bulk request for workflows in one call. Use `.append()` on bulk_workflows instance
to add however-many-records to call in bulk.
```python3
from suprsend import WorkflowTriggerRequest
bulk_ins = supr_client.workflows.bulk_trigger_instance()
# one or more workflow instances
workflow1 = WorkflowTriggerRequest(body={...}) # body must be a proper workflow request json/dict
workflow2 = WorkflowTriggerRequest(body={...}) # body must be a proper workflow request json/dict
# --- use .append on bulk instance to add one or more records
bulk_ins.append(workflow1)
bulk_ins.append(workflow2)
# OR
bulk_ins.append(workflow1, workflow2)
# -------
response = bulk_ins.trigger()
print(response)
```
* There isn't any limit on number-of-records that can be added to bulk_workflows instance.
* On calling `bulk_ins.trigger()` the SDK internally makes one-or-more Callable-chunks.
* each callable-chunk contains a subset of records, the subset calculation is based on each record's bytes-size
and max allowed chunk-size and chunk-length etc.
* for each callable-chunk SDK makes an HTTP call to SuprSend To register the request.
### Set channels in User Profile
If you regularly trigger a workflow for users on some pre-decided channels,
then instead of adding user-channel-details in each workflow request, you can set those channel-details in user
profile once, and after that, in workflow trigger request you only need to pass the distinct_id of the user.
All associated channels in User profile will be automatically picked when executing the workflow.
- First Instantiate a user object
```python
distinct_id = "__uniq_user_id__" # Unique id of user in your application
# Instantiate User profile
user = supr_client.user.get_instance(distinct_id=distinct_id)
```
- To add channel details to this user (viz. email, sms, whatsapp, androidpush, iospush etc)
use `user.add_*` method(s) as shown in the example below.
```python
# Add channel details to user-instance. Call relevant add_* methods
user.add_email("user@example.com") # - To add Email
user.add_sms("+919999999999") # - To add SMS
user.add_whatsapp("+919999999999") # - To add Whatsapp
user.add_androidpush("__android_push_fcm_token__") # - by default, token is assumed to be fcm-token
# You can set the optional provider value [fcm/xiaomi/oppo] if its not a fcm-token
user.add_androidpush("__android_push_xiaomi_token__", provider="xiaomi")
user.add_iospush("__iospush_token__")
user.add_slack({"email": "user@example.com", "access_token": "xoxb-XXXXXXXXXXXX"}) # - DM user using email
user.add_slack({"user_id": "U03XXXXXXXX", "access_token": "xoxb-XXXXXXXXXXXX"}) # - DM user using slack member_id if known
user.add_slack({"channel_id": "C03XXXXXXXX", "access_token": "xoxb-XXXXXXXXXXXX"}) # - Use channel id
user.add_slack({"incoming_webhook": {"url": "https://hooks.slack.com/services/TXXXXXXXXX/BXXXXXX/XXXXXXX"}}) # - Use incoming webhook
user.add_ms_teams({"tenant_id": "XXXXXXX", "service_url": "https://smba.trafficmanager.net/XXXXXXXXXX", "conversation_id": "XXXXXXXXXXXX"}) # - DM on Team's channel using conversation id
user.add_ms_teams({"tenant_id": "XXXXXXX", "service_url": "https://smba.trafficmanager.net/XXXXXXXXXX", "user_id": "XXXXXXXXXXXX"}) # - DM user using team user id
user.add_ms_teams({"incoming_webhook": {"url": "https://XXXXX.webhook.office.com/webhookb2/XXXXXXXXXX@XXXXXXXXXX/IncomingWebhook/XXXXXXXXXX/XXXXXXXXXX"}}) # - Use incoming webhook
# After setting the channel details on user-instance, call save()
response = user.save()
print(response)
```
```python
# Response structure
{
"success": True, # if true, request was accepted.
"status": "success",
"status_code": 202, # http status code
"message": "OK",
}
{
"success": False, # error will be present in message
"status": "fail",
"status_code": 500, # http status code
"message": "error message",
}
```
- Similarly, If you want to remove certain channel details from user,
you can call `user.remove_*` method as shown in the example below.
```python
# Remove channel helper methods
user.remove_email("user@example.com")
user.remove_sms("+919999999999")
user.remove_whatsapp("+919999999999")
user.remove_androidpush("__android_push_fcm_token__")
user.remove_androidpush("__android_push_xiaomi_token__", provider="xiaomi")
user.remove_iospush("__iospush_token__")
user.remove_slack({"email": "user@example.com", "access_token": "xoxb-XXXXXXXXXXXX"}) # - DM user using email
user.remove_slack({"user_id": "U03XXXXXXXX", "access_token": "xoxb-XXXXXXXXXXXX"}) # - DM user using slack member_id if known
user.remove_slack({"channel_id": "C03XXXXXXXX", "access_token": "xoxb-XXXXXXXXXXXX"}) # - Use channel id
user.remove_slack({"incoming_webhook": {"url": "https://hooks.slack.com/services/TXXXXXXXXX/BXXXXXX/XXXXXXX"}}) # - Use incoming webhook
user.remove_ms_teams({"tenant_id": "XXXXXXX", "service_url": "https://smba.trafficmanager.net/XXXXXXXXXX", "conversation_id": "XXXXXXXXXXXX"}) # - DM on Team's channel using conversation id
user.remove_ms_teams({"tenant_id": "XXXXXXX", "service_url": "https://smba.trafficmanager.net/XXXXXXXXXX", "user_id": "XXXXXXXXXXXX"}) # - DM user using team user id
user.remove_ms_teams({"incoming_webhook": {"url": "https://XXXXX.webhook.office.com/webhookb2/XXXXXXXXXX@XXXXXXXXXX/IncomingWebhook/XXXXXXXXXX/XXXXXXXXXX"}}) # - Use incoming webhook
# save
response = user.save()
print(response)
```
- If you need to delete/unset all emails (or any other channel) of a user,
you can call `unset` method on the user instance.
The method accepts the channel key/s (a single key or list of keys)
```python
# --- To delete all emails associated with user
user.unset("$email")
response = user.save()
print(response)
# what value to pass to unset channels
# for email: $email
# for whatsapp: $whatsapp
# for SMS: $sms
# for androidpush tokens: $androidpush
# for iospush tokens: $iospush
# for webpush tokens: $webpush
# for slack: $slack
# for ms_teams: $ms_teams
# --- multiple channels can also be deleted in one call by passing argument as a list
user.unset(["$email", "$sms", "$whatsapp"])
user.save()
```
- You can also set preferred language of user using `set_preferred_language(lang_code)`. Value for lang_code
must be 2-letter code in the `ISO 639-1 Alpha-2 code` format.
e.g. en (for English), es (for Spanish), fr (for French) etc.
```python
# --- Set 2-letter language code in "ISO 639-1 Alpha-2" format
user.set_preferred_language("en")
response = user.save()
print(response)
```
- You can also set timezone of user using `set_timezone(timezone)`. Value for timezone
must be from amongst the IANA timezones as maintained in the latest release here:
https://data.iana.org/time-zones/tzdb-2024a/zonenow.tab.
```python
# --- Set timezone property at user level in IANA timezone format
user.set_timezone("America/Los_Angeles")
response = user.save()
print(response)
```
- Note: After calling `add_*`/`remove_*`/`unset`/`set_*` methods, don't forget to call `user.save()`. On call of save(),
SDK sends the request to SuprSend platform to update the User-Profile.
Once channels details are set at User profile, you only have to mention the user's distinct_id
while triggering workflow. Associated channels will automatically be picked up from user-profile
while processing the workflow. In the example below, we are passing only distinct_id of the user:
```python3
from suprsend import WorkflowTriggerRequest
# Prepare Workflow body
request_body = {
"workflow": "purchase-made",
"recipients": [
{
"distinct_id": "0f988f74-6982-41c5-8752-facb6911fb08",
}
],
# data can be any json / serializable python-dictionary
"data": {
"first_name": "User",
"spend_amount": "$10",
"nested_key_example": {
"nested_key1": "some_value_1",
"nested_key2": {
"nested_key3": "some_value_3",
},
}
}
}
wf = WorkflowTriggerRequest(body=request_body)
# Trigger workflow
response = supr_client.workflows.trigger(wf)
print(response)
```
#### Bulk API for Users
You can send multiple subscriber requests in one call. Use `.append()` on bulk_users instance
to add however-many-records to call in bulk.
```python3
bulk_ins = supr_client.bulk_users.new_instance()
# Prepare multiple users
u1 = supr_client.user.get_instance("distinct_id_1") # User 1
u1.set_email("u1@example.com")
u2 = supr_client.user.get_instance("distinct_id_2") # User 2
u2.set_email("u2@example.com")
# --- use .append on bulk instance to add one or more records
bulk_ins.append(u1)
bulk_ins.append(u2)
# OR
bulk_ins.append(u1, u2)
# -------
response = bulk_ins.save()
print(response)
```
### Track and Send Event
You can track and send events to SuprSend platform by using `supr_client.track_event` method.
An event is composed of an `event_name`, tracked wrt a user: `distinct_id`, with event-attributes: `properties`
```python3
from suprsend import Event
# Example
distinct_id = "__uniq_user_id__" # Mandatory, Unique id of user in your application
event_name = "__event_name__" # Mandatory, name of the event you're tracking
properties = {} # Optional, default=None, a dict representing event-attributes
event = Event(distinct_id=distinct_id, event_name=event_name, properties=properties)
# You can also add Idempotency-key
event = Event(distinct_id=distinct_id, event_name=event_name, properties=properties,
idempotency_key="__uniq_request_id__")
# You can also pass the tenant_id to be used for templates/notifications
event = Event(distinct_id=distinct_id, event_name=event_name, properties=properties,
idempotency_key="__uniq_request_id__", tenant_id="default")
# Send event
response = supr_client.track_event(event)
print(response)
```
```python
# Response structure
{
"success": True, # if true, request was accepted.
"status": "success",
"status_code": 202, # http status code
"message": "OK",
}
{
"success": False, # error will be present in message
"status": "fail",
"status_code": 500, # http status code
"message": "error message",
}
```
#### Bulk API for events
You can send multiple events in one call. Use `.append()` on bulk_events instance
to add however-many-records to call in bulk.
```python3
from suprsend import Event
bulk_ins = supr_client.bulk_events.new_instance()
# Example
e1 = Event("distinct_id1", "event_name1", {"k1": "v1"}) # Event 1
e2 = Event("distinct_id2", "event_name2", {"k2": "v2"}) # Event 2
# --- use .append on bulk instance to add one or more records
bulk_ins.append(e1)
bulk_ins.append(e2)
# OR
bulk_ins.append(e1, e2)
# -------
response = bulk_ins.trigger()
print(response)
```
| text/markdown | Suprsend | sanjeev@suprsend.com | null | null | null | null | [
"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"
] | [] | https://github.com/suprsend/suprsend-py-sdk | null | >=3.9 | [] | [] | [] | [
"jsonschema",
"requests",
"python-magic"
] | [] | [] | [] | [
"Bug Tracker, https://github.com/suprsend/suprsend-py-sdk/issues"
] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T14:27:48.196138 | suprsend_py_sdk-0.17.0.tar.gz | 45,431 | 98/d6/4b957726de49796c3b3dc414033ece45eebf05e5e6f035e7bd3d5ced4480/suprsend_py_sdk-0.17.0.tar.gz | source | sdist | null | false | d8dff7de423e96b906b6aa3288c8fcb7 | 9c8d66d8965b1095732b78e2d4b3949db1621d67a68fa024029cae494457e901 | 98d64b957726de49796c3b3dc414033ece45eebf05e5e6f035e7bd3d5ced4480 | null | [
"LICENSE"
] | 705 |
2.4 | deepsigma | 2.0.0 | Σ OVERWATCH — Institutional Decision Infrastructure for coherence, credibility, and drift governance | [](https://github.com/8ryanWh1t3/DeepSigma/actions/workflows/ci.yml)
[](./LICENSE)
[](https://www.python.org/downloads/)
<div align="center">
# Institutional Decision Infrastructure
**Truth · Reasoning · Memory**
[🚀 Start Here](START_HERE.md) · [🔁 Hero Demo](HERO_DEMO.md) · [🏢 Boardroom Brief](category/boardroom_brief.md) · [📜 Specs](canonical/) · [🗺️ Navigation](NAV.md) · [🔬 RAL](ABOUT.md)
</div>
---
## The Problem
Your organization makes thousands of decisions. Almost none are structurally recorded with their reasoning, evidence, or assumptions.
- **Leader leaves** → their rationale leaves with them.
- **Conditions change** → nobody detects stale assumptions.
- **Incident occurs** → root-cause analysis becomes guessing.
- **AI accelerates decisions 100×** → governance designed for human speed fails silently.
This is not a documentation gap. It is a **missing infrastructure layer**.
Every institution pays this cost — in re-litigation, audit overhead, governance drag, and silent drift. The question: keep paying in consequences, or invest in prevention.
→ [Full economic tension analysis](category/economic_tension.md) · [Boardroom brief](category/boardroom_brief.md) · [Risk model](category/risk_model.md)
---
## The Solution
**Σ OVERWATCH** fills the void between systems of record and systems of engagement with a **system of decision**.
Every decision flows through three primitives:
| Primitive | Artifact | What It Captures |
|-----------|----------|------------------|
| **Truth** | Decision Ledger Record (DLR) | What was decided, by whom, with what evidence |
| **Reasoning** | Reasoning Scaffold (RS) | Why this choice — claims, counter-claims, weights |
| **Memory** | Decision Scaffold + Memory Graph (DS + MG) | Reusable templates + queryable institutional memory |
When assumptions decay, **Drift** fires.
When drift exceeds tolerance, a **Patch** corrects it.
This is the **Drift → Patch loop** — continuous self-correction.
---
## Progressive Escalation
Coherence Ops scales from a single decision loop to institutional credibility infrastructure:
| Level | Scale | What It Proves |
|-------|-------|---------------|
| **Mini Lattice** | 12 nodes | Mechanics: one claim, three evidence streams, TTL, drift, patch, seal |
| **Enterprise Lattice** | ~500 nodes | Complexity: K-of-N quorum, correlation groups, regional validators, sync nodes |
| **Credibility Engine** | 30,000–40,000 nodes | Survivability: multi-region, automated drift, continuous sealing, hot/warm/cold |
Same primitives. Same artifacts. Same loop. Different scale.
> Examples: [Mini Lattice](examples/01-mini-lattice/) · [Enterprise Lattice](examples/02-enterprise-lattice/) · [Credibility Engine Scale](examples/03-credibility-engine-scale/) · [Full docs](docs/credibility-engine/)
>
> Demo: [Credibility Engine Cockpit](dashboard/credibility-engine-demo/) — static dashboard, 7 panels, 30 seconds to institutional state
>
> Stage 2: [Simulated Engine](sim/credibility-engine/) — live simulation driver, 4 scenarios (Day0–Day3), 2-second ticks
>
> Stage 3: [Runtime Engine](credibility_engine/) — real engine with JSONL persistence + API endpoints
---
## Why Scale Changes Everything
At 12 nodes, a human can trace every dependency. At 500, hidden correlations emerge. At 40,000, manual governance is impossible.
| Principle | Why It Matters at Scale |
|-----------|------------------------|
| **Truth decays** | Evidence has a shelf life. Without TTL discipline, stale assertions masquerade as current truth. |
| **Silence is signal** | A lattice that stops producing drift signals is not healthy — it is blind. Watch for instability, not absence. |
| **Independence must be enforced** | Sources that appear independent may share infrastructure. Correlation groups make hidden dependencies visible. |
| **Drift is normal** | 100–400 drift events per day is steady state at production scale. Drift is maintenance fuel, not crisis. |
| **Seal authority matters** | No single region should control institutional truth. Authority distribution (no region >40%) prevents capture. |
At every scale, the same question: **can the institution trust its own assertions right now?** The Credibility Index answers it with a number. The Drift→Patch→Seal loop keeps that number honest.
---
## Stage 2 — Simulated Credibility Engine
Run the simulation driver to power the dashboard with live synthetic data:
```bash
# Terminal 1: Start simulation (Day0 = stable baseline)
python sim/credibility-engine/runner.py --scenario day0
# Terminal 2: Serve dashboard
python -m http.server 8000
```
Visit: [http://localhost:8000/dashboard/credibility-engine-demo/](http://localhost:8000/dashboard/credibility-engine-demo/)
Four scenarios model progressive institutional entropy: Day0 (stable), Day1 (entropy emerges), Day2 (coordinated darkness), Day3 (external mismatch + recovery). The dashboard updates every 2 seconds.
> [Simulation docs](sim/credibility-engine/) · [Dashboard](dashboard/credibility-engine-demo/)
---
## Stage 3 — Multi-Tenant Credibility Engine (v0.8.0)
Run the API server to serve live credibility state:
```bash
uvicorn dashboard.api_server:app --reload
```
Engine persists live state under `data/credibility/{tenant_id}/`. Dashboard supports tenant + role selection in API mode (`DATA_MODE = "API"` in `app.js`).
**Tenant-scoped API routes:** `/api/{tenant_id}/credibility/*`
| Endpoint | Description |
|----------|-------------|
| `GET /api/tenants` | List all registered tenants |
| `GET /api/{tenant_id}/credibility/snapshot` | Credibility Index, band, components, trend |
| `GET /api/{tenant_id}/credibility/claims/tier0` | Tier 0 claims with quorum and TTL |
| `GET /api/{tenant_id}/credibility/drift/24h` | Drift events by severity, category, region |
| `GET /api/{tenant_id}/credibility/correlation` | Correlation cluster map |
| `GET /api/{tenant_id}/credibility/sync` | Sync plane integrity |
| `POST /api/{tenant_id}/credibility/packet/generate` | Generate credibility packet (any role) |
| `POST /api/{tenant_id}/credibility/packet/seal` | Seal packet (requires `coherence_steward`) |
Alias routes at `/api/credibility/*` remain for backward compatibility (serve default tenant).
**Quick start:**
1. `uvicorn dashboard.api_server:app --reload`
2. Open dashboard, select tenant + role
3. Generate + seal packet
> [Runtime Engine docs](credibility_engine/) · [API Reference](docs/credibility-engine/API_V0_8.md) · [Tenancy Spec](docs/credibility-engine/TENANCY_SPEC.md)
---
## Try It (5 Minutes)
```bash
git clone https://github.com/8ryanWh1t3/DeepSigma.git && cd DeepSigma
pip install -r requirements.txt
# Score coherence (0–100, A–F)
python -m coherence_ops score ./coherence_ops/examples/sample_episodes.json --json
# Full pipeline: episodes → DLR → RS → DS → MG → report
python -m coherence_ops.examples.e2e_seal_to_report
# Why did we make this decision?
python -m coherence_ops iris query --type WHY --target ep-001
```
**Drift → Patch in 60 seconds** (v0.3.0):
```bash
python -m coherence_ops.examples.drift_patch_cycle
# BASELINE 90.00 (A) → DRIFT 85.75 (B) → PATCH 90.00 (A)
```
👉 Full walkthrough: [HERO_DEMO.md](HERO_DEMO.md) — 8 steps, every artifact touched.
---
## Golden Path (v0.5.1)
One command. One outcome. No ambiguity. Proves the full 7-step loop end-to-end:
Connect → Normalize → Extract → Seal → Drift → Patch → Recall.
```bash
# Local (fixture mode — no credentials)
deepsigma golden-path sharepoint \
--fixture demos/golden_path/fixtures/sharepoint_small --clean
# Or via the coherence CLI
coherence golden-path sharepoint \
--fixture demos/golden_path/fixtures/sharepoint_small
# Docker
docker compose --profile golden-path run --rm golden-path
```
Output: `golden_path_output/` with per-step JSON artifacts and `summary.json`.
👉 Details: [demos/golden_path/README.md](demos/golden_path/README.md)
---
## Trust Scorecard (v0.6.0)
Measurable SLOs from every Golden Path run. Generated automatically in CI.
```bash
python -m tools.trust_scorecard \
--input golden_path_ci_out --output trust_scorecard.json
# With coverage
python -m tools.trust_scorecard \
--input golden_path_ci_out --output trust_scorecard.json --coverage 85.3
```
Output: `trust_scorecard.json` with metrics, SLO checks, and timing data.
👉 Spec: [specs/trust_scorecard_v1.md](specs/trust_scorecard_v1.md) · Dashboard: **Trust Scorecard** tab
---
## Creative Director Suite (v0.6.2)
Excel-first Coherence Ops — govern creative decisions in a shared workbook that any team can edit in SharePoint. No code required.
```bash
# Generate the governed workbook
pip install -e ".[excel]"
python tools/generate_cds_workbook.py
# Explore the sample dataset
ls datasets/creative_director_suite/samples/
```
The workbook includes a `BOOT` sheet (LLM system prompt), 7 named governance tables (tblTimeline, tblDeliverables, tblDLR, tblClaims, tblAssumptions, tblPatchLog, tblCanonGuardrails), and a Coherence Index dashboard.
**Quickstart:**
1. Download the template workbook from `templates/creative_director_suite/`
2. Fill `BOOT!A1` (or use the pre-filled template)
3. Attach workbook to your LLM app (ChatGPT, Claude, Copilot)
4. Respond to: **"What Would You Like To Do Today?"**
5. Paste write-back rows into Excel tables
> Docs: [Excel-First Guide](docs/excel-first/multi-dim-prompting-for-teams/README.md) · [Boot Protocol](docs/excel-first/WORKBOOK_BOOT_PROTOCOL.md) · [Table Schemas](docs/excel-first/TABLE_SCHEMAS.md) · [Dataset](datasets/creative_director_suite/README.md)
---
## Excel-first Money Demo (v0.6.3)
One command. Deterministic Drift→Patch proof — no LLM, no network.
```bash
python -m demos.excel_first --out out/excel_money_demo
# Or via console entry point
excel-demo --out out/excel_money_demo
```
Output: `workbook.xlsx`, `run_record.json`, `drift_signal.json`, `patch_stub.json`, `coherence_delta.txt`
> Docs: [Money Demo](docs/excel-first/MONEY_DEMO.md) · [BOOT Validator](tools/validate_workbook_boot.py) · [MDPT Power App Pack](docs/excel-first/multi-dim-prompting-for-teams/POWER_AUTOMATE_FLOWS.md)
---
## MDPT Beta Kit (v0.6.4)
Registry index, product CLI, and Power App starter kit for governed prompt operations.
```mermaid
flowchart TB
subgraph SharePoint["SharePoint Lists"]
PC[PromptCapabilities<br/>Master Registry]
PR[PromptRuns<br/>Execution Log]
DP[DriftPatches<br/>Patch Queue]
end
subgraph Generator["MDPT Index Generator"]
CSV[CSV Export] --> GEN[generate_prompt_index.py]
GEN --> IDX[prompt_index.json]
GEN --> SUM[prompt_index_summary.md]
end
subgraph Lifecycle["Prompt Lifecycle"]
direction LR
INDEX[1. Index] --> CATALOG[2. Catalog]
CATALOG --> USE[3. Use]
USE --> LOG[4. Log]
LOG --> DRIFT[5. Drift]
DRIFT --> PATCH[6. Patch]
PATCH -.->|refresh| INDEX
end
PC -->|export| CSV
INDEX -.-> PC
USE -.-> PR
DRIFT -.-> DP
PATCH -.-> DP
style SharePoint fill:#0078d4,stroke:#0078d4,color:#fff
style Generator fill:#16213e,stroke:#0f3460,color:#fff
style Lifecycle fill:#0f3460,stroke:#0f3460,color:#fff
```
```bash
# Generate MDPT Prompt Index from SharePoint export
deepsigma mdpt index --csv prompt_export.csv --out out/mdpt
# Product CLI
deepsigma doctor # Environment health check
deepsigma demo excel --out out/excel_money_demo # Excel-first Money Demo
deepsigma validate boot <file.xlsx> # BOOT contract validation
deepsigma golden-path sharepoint --fixture ... # 7-step Golden Path
```
> Docs: [CLI Reference](docs/CLI.md) · [MDPT](mdpt/README.md) · [Power App Starter Kit](mdpt/powerapps/STARTER_KIT.md)
---
## Credibility Engine (v0.6.4)
Institutional-scale claim lattice with formal credibility scoring, evidence synchronization, and automated drift governance.
**Credibility Index** — composite 0–100 score from 6 components:
| Component | What It Measures |
|-----------|-----------------|
| Tier-weighted claim integrity | Higher-tier claims weigh more |
| Drift penalty | Active drift signals reduce score |
| Correlation risk penalty | Shared source dependencies penalized |
| Quorum margin compression | Thin redundancy penalized |
| TTL expiration penalty | Stale evidence penalized |
| Independent confirmation bonus | 3+ independent sources rewarded |
| Score | Band | Action |
|-------|------|--------|
| 95–100 | Stable | Monitor |
| 85–94 | Minor drift | Review |
| 70–84 | Elevated risk | Patch required |
| 50–69 | Structural degradation | Immediate remediation |
| <50 | Compromised | Halt dependent decisions |
**Institutional Drift Categories** — 5 scale-level patterns composing from 8 runtime drift types: timing entropy, correlation drift, confidence volatility, TTL compression, external mismatch.
**Sync Plane** — evidence timing infrastructure. Sync nodes are evidence about evidence. Event time vs. ingest time, monotonic sequences, independent beacons, watermark logic.
**Category Definition:**
Coherence Ops is not monitoring, observability, or compliance. It is the operating layer that prevents institutions from lying to themselves over time.
**Deployment:**
- MVP: 6–8 engineers, $1.5M–$3M/year
- Production: 30k–40k nodes, 3+ regions, $6M–$10M/year (~$170–$280/node/year)
> Docs: [Credibility Engine](docs/credibility-engine/) · [Credibility Index](docs/credibility-engine/credibility_index.md) · [Sync Plane](docs/credibility-engine/sync_plane.md) · [Deployment Patterns](docs/credibility-engine/deployment_patterns.md)
>
> Diagrams: [Lattice Architecture](mermaid/38-lattice-architecture.md) · [Drift Loop](mermaid/39-drift-loop.md)
>
> Examples: [Mini Lattice](examples/01-mini-lattice/) · [Enterprise Lattice](examples/02-enterprise-lattice/) · [Scale](examples/03-credibility-engine-scale/)
**Guardrails:** Abstract model for institutional credibility infrastructure. Not domain-specific. Not modeling real-world weapons. Pure decision infrastructure.
---
## Repo Structure
```
DeepSigma/
├─ START_HERE.md # Front door
├─ HERO_DEMO.md # 5-min hands-on walkthrough
├─ NAV.md # Navigation index
├── category/ # Economic tension, boardroom brief, risk model
├── canonical/ # Normative specs: DLR, RS, DS, MG, Prime Constitution
├── coherence_ops/ # Python library + CLI + examples
├── deepsigma/cli/ # Unified product CLI (doctor, demo, validate, mdpt, golden-path)
├── mdpt/ # MDPT tools, templates, Power App starter kit
├── specs/ # JSON schemas (11 schemas)
├── examples/ # Episodes, drift events, demo data
├── llm_data_model/ # LLM-optimized canonical data model
├── datasets/ # Creative Director Suite sample data (8 CSVs)
├── docs/ # Extended docs (vision, IRIS, policy packs, Excel-first)
├── templates/ # Excel workbook templates
├── docs/credibility-engine/ # Credibility Index, Sync Plane, deployment patterns
├── mermaid/ # 39+ architecture & flow diagrams
├── engine/ # Compression, degrade ladder, supervisor
├── dashboard/ # React dashboard + mock API
├── adapters/ # MCP, OpenClaw, SharePoint, Power Platform, AskSage, Snowflake, LangChain
├── demos/ # Golden Path end-to-end demo + fixtures
└── release/ # Release readiness checklist
```
---
## CLI Quick Reference
| Command | Purpose |
|---------|---------|
| `python -m coherence_ops audit <path>` | Cross-artifact consistency audit |
| `python -m coherence_ops score <path> [--json]` | Coherence score (0–100, A–F) |
| `python -m coherence_ops mg export <path> --format=json` | Export Memory Graph |
| `python -m coherence_ops iris query --type WHY --target <id>` | Why was this decided? |
| `python -m coherence_ops iris query --type WHAT_DRIFTED --json` | What assumptions decayed? |
| `python -m coherence_ops demo <path>` | Score + IRIS in one command |
| `coherence reconcile <path> [--auto-fix] [--json]` | Reconcile cross-artifact inconsistencies |
| `coherence schema validate <file> --schema <name>` | Validate JSON against named schema |
| `coherence dte check <path> --dte <spec>` | Check episodes against DTE constraints |
| `deepsigma doctor` | Environment health check |
| `deepsigma demo excel [--out DIR]` | Excel-first Money Demo |
| `deepsigma validate boot <file.xlsx>` | BOOT contract validation |
| `deepsigma mdpt index --csv <file>` | Generate MDPT Prompt Index |
| `deepsigma golden-path <source> [--fixture <path>]` | 7-step end-to-end Golden Path |
---
## Connectors (v0.6.0)
All connectors conform to the [Connector Contract v1.0](specs/connector_contract_v1.md) — a standard interface with a canonical Record Envelope for provenance, hashing, and access control.
| Connector | Transport | MCP Tools | Docs |
|-----------|-----------|-----------|------|
| SharePoint | Graph API | `sharepoint.list` / `get` / `sync` | [docs/26](docs/26-sharepoint-connector.md) |
| Power Platform | Dataverse Web API | `dataverse.list` / `get` / `query` | [docs/27](docs/27-power-platform-connector.md) |
| AskSage | REST API | `asksage.query` / `models` / `datasets` / `history` | [docs/28](docs/28-asksage-connector.md) |
| Snowflake | Cortex + SQL API | `cortex.complete` / `embed` / `snowflake.query` / `tables` / `sync` | [docs/29](docs/29-snowflake-connector.md) |
| LangChain | Callback | Governance + Exhaust handlers | [docs/23](docs/23-langgraph-adapter.md) |
| OpenClaw | HTTP | Dashboard API client | [adapters/openclaw/](adapters/openclaw/) |
---
## Key Links
| Resource | Path |
|----------|------|
| Reality Await Layer (RAL) | [ABOUT.md](ABOUT.md) |
| Front door | [START_HERE.md](START_HERE.md) |
| Hero demo | [HERO_DEMO.md](HERO_DEMO.md) |
| Boardroom brief | [category/boardroom_brief.md](category/boardroom_brief.md) |
| Economic tension | [category/economic_tension.md](category/economic_tension.md) |
| Risk model | [category/risk_model.md](category/risk_model.md) |
| Canonical specs | [/canonical/](canonical/) |
| JSON schemas | [/specs/](specs/) |
| Python library | [/coherence_ops/](coherence_ops/) |
| IRIS docs | [docs/18-iris.md](docs/18-iris.md) |
| Docs map | [docs/99-docs-map.md](docs/99-docs-map.md) |
---
## Operations
| Resource | Purpose |
|----------|---------|
| [OPS_RUNBOOK.md](OPS_RUNBOOK.md) | Run Money Demo, tests, diagnostics, incident playbooks |
| [TROUBLESHOOTING.md](TROUBLESHOOTING.md) | Top 20 issues — symptom → cause → fix → verify |
| [CONFIG_REFERENCE.md](CONFIG_REFERENCE.md) | All CLI args, policy pack schema, environment variables |
| [STABILITY.md](STABILITY.md) | What's stable, what's not, versioning policy, v1.0 criteria |
| [TEST_STRATEGY.md](TEST_STRATEGY.md) | Test tiers, SLOs, how to run locally, coverage |
**Run with coverage:**
```bash
pytest --cov=coherence_ops --cov-report=term-missing
```
---
## Contributing
See [CONTRIBUTING.md](CONTRIBUTING.md). All contributions must maintain consistency with Truth · Reasoning · Memory and the four canonical artifacts (DLR / RS / DS / MG).
## License
See [LICENSE](LICENSE).
---
<div align="center">
**Σ OVERWATCH**
*We don't sell agents. We sell the ability to trust them.*
</div>
| text/markdown | null | Bryan David White <8ryanWh1t3@gmail.com> | null | null | MIT | agentic-ai, governance, coherence-ops, decision-episodes, drift-patch | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries :: Application Frameworks"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"jsonschema",
"referencing>=0.35.0",
"pyyaml>=6.0",
"opentelemetry-api>=1.20.0; extra == \"otel\"",
"opentelemetry-sdk>=1.20.0; extra == \"otel\"",
"opentelemetry-exporter-otlp>=1.20.0; extra == \"otel\"",
"anthropic>=0.40.0; extra == \"exhaust-llm\"",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"pytest-benchmark; extra == \"dev\"",
"ruff; extra == \"dev\"",
"langgraph>=0.2.0; extra == \"langgraph\"",
"httpx>=0.25.0; extra == \"mesh\"",
"uvicorn>=0.24.0; extra == \"mesh\"",
"msgpack>=1.0.0; extra == \"mesh\"",
"msal>=1.25.0; extra == \"azure\"",
"cryptography>=42.0; extra == \"snowflake\"",
"rdflib<8,>=7.0; extra == \"rdf\"",
"pyparsing>=3.1; extra == \"rdf\"",
"pyshacl>=0.25; extra == \"rdf\"",
"wasmtime>=23.0; extra == \"openclaw\"",
"openpyxl>=3.1.0; extra == \"excel\"",
"psycopg[binary]>=3.1.0; extra == \"postgresql\""
] | [] | [] | [] | [
"Homepage, https://github.com/8ryanWh1t3/DeepSigma",
"Repository, https://github.com/8ryanWh1t3/DeepSigma",
"Wiki, https://github.com/8ryanWh1t3/DeepSigma/wiki",
"Issues, https://github.com/8ryanWh1t3/DeepSigma/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:27:15.865452 | deepsigma-2.0.0.tar.gz | 339,560 | 7a/1f/8b82bdb3c54f28e42157d88f9d25d53492d0882b0f9cdc4f5c18da92a52b/deepsigma-2.0.0.tar.gz | source | sdist | null | false | 244c3e4436068f516c5ae43ab8e4f6bc | 48fdfde14393cbd46f5bb7456d571091853b743d3290842e5d7d7c5fa2f30716 | 7a1f8b82bdb3c54f28e42157d88f9d25d53492d0882b0f9cdc4f5c18da92a52b | null | [
"LICENSE"
] | 225 |
2.4 | vd-dlt-registry | 0.1.1 | Connector registry for vd-dlt pipeline ecosystem | # vd-dlt-registry
Connector registry for the vd-dlt pipeline ecosystem.
## Overview
This package provides the master catalog of available dlt connectors. It contains a single `registry.yml` file that lists all verified connectors with their versions, status, and metadata.
## Usage
The registry is automatically loaded by the vd-dlt pipeline runner and the Studio application to discover available connectors.
## Registry Format
```yaml
connectors:
connector_name:
latest: "1.0.0"
min_supported: "1.0.0"
status: verified | experimental | deprecated
maintainer: vibedata-core
description: "Connector description"
```
## Available Connectors
- **notion**: Notion databases and pages
- **rest_api_generic**: Generic REST API connector for any API
- **salesforce**: Salesforce CRM objects and data
| text/markdown | null | VibeData <info@vibedata.dev> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Topic :: Database"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"pyyaml>=6.0"
] | [] | [] | [] | [
"Homepage, https://github.com/accelerate-data/vd-dlt-connectors",
"Repository, https://github.com/accelerate-data/vd-dlt-connectors"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:26:49.360227 | vd_dlt_registry-0.1.1.tar.gz | 1,681 | 5f/ed/70a6ae20fdd7072877def3a553207bf8650185ac25f29956e71e3d6b96dc/vd_dlt_registry-0.1.1.tar.gz | source | sdist | null | false | 29cedd58da0a6bccd379738565e4cb71 | b9182f425622ba512a4d5c1835d7d2ca242b4adb557b84186dcb2d04928c65e5 | 5fed70a6ae20fdd7072877def3a553207bf8650185ac25f29956e71e3d6b96dc | MIT | [] | 219 |
2.4 | fastapi-toolsets | 1.0.0 | Reusable tools for FastAPI: async CRUD, fixtures, CLI, and standardized responses for SQLAlchemy + PostgreSQL | # FastAPI Toolsets
A modular collection of production-ready utilities for FastAPI. Install only what you need — from async CRUD and database helpers to CLI tooling, Prometheus metrics, and pytest fixtures. Each module is independently installable via optional extras, keeping your dependency footprint minimal.
[](https://github.com/d3vyce/fastapi-toolsets/actions/workflows/ci.yml)
[](https://codecov.io/gh/d3vyce/fastapi-toolsets)
[](https://github.com/astral-sh/ty)
[](https://github.com/astral-sh/uv)
[](https://github.com/astral-sh/ruff)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
---
**Documentation**: [https://fastapi-toolsets.d3vyce.fr](https://fastapi-toolsets.d3vyce.fr)
**Source Code**: [https://github.com/d3vyce/fastapi-toolsets](https://github.com/d3vyce/fastapi-toolsets)
---
## Installation
The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, logging):
```bash
uv add fastapi-toolsets
```
Install only the extras you need:
```bash
uv add "fastapi-toolsets[cli]" # CLI (typer)
uv add "fastapi-toolsets[metrics]" # Prometheus metrics (prometheus_client)
uv add "fastapi-toolsets[pytest]" # Pytest helpers (httpx, pytest-xdist)
```
Or install everything:
```bash
uv add "fastapi-toolsets[all]"
```
## Features
### Core
- **CRUD**: Generic async CRUD operations with `CrudFactory`, built-in search with relationship traversal
- **Database**: Session management, transaction helpers, table locking, and polling-based row change detection
- **Dependencies**: FastAPI dependency factories (`PathDependency`, `BodyDependency`) for automatic DB lookups from path or body parameters
- **Fixtures**: Fixture system with dependency management, context support, and pytest integration
- **Standardized API Responses**: Consistent response format with `Response`, `PaginatedResponse`, and `PydanticBase`
- **Exception Handling**: Structured error responses with automatic OpenAPI documentation
- **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`
### Optional
- **CLI**: Django-like command-line interface with fixture management and custom commands support
- **Metrics**: Prometheus metrics endpoint with provider/collector registry
- **Pytest Helpers**: Async test client, database session management, `pytest-xdist` support, and table cleanup utilities
## License
MIT License - see [LICENSE](LICENSE) for details.
## Contributing
Contributions are welcome! Please feel free to submit issues and pull requests.
| text/markdown | d3vyce | d3vyce <contact@d3vyce.fr> | null | null | null | fastapi, sqlalchemy, postgresql | [
"Development Status :: 4 - Beta",
"Framework :: AsyncIO",
"Framework :: FastAPI",
"Framework :: Pydantic",
"Intended Audience :: Developers",
"Intended Audience :: Information Technology",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"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",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development",
"Typing :: Typed"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"asyncpg>=0.29.0",
"fastapi>=0.100.0",
"pydantic>=2.0",
"sqlalchemy[asyncio]>=2.0",
"fastapi-toolsets[cli,metrics,pytest]; extra == \"all\"",
"typer>=0.9.0; extra == \"cli\"",
"prometheus-client>=0.20.0; extra == \"metrics\"",
"httpx>=0.25.0; extra == \"pytest\"",
"pytest-xdist>=3.0.0; extra == \"pytest\"",
"pytest>=8.0.0; extra == \"pytest\""
] | [] | [] | [] | [
"Homepage, https://github.com/d3vyce/fastapi-toolsets",
"Documentation, https://fastapi-toolsets.d3vyce.fr/",
"Repository, https://github.com/d3vyce/fastapi-toolsets",
"Issues, https://github.com/d3vyce/fastapi-toolsets/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:26:45.022157 | fastapi_toolsets-1.0.0.tar.gz | 28,291 | 84/17/84c78fa6cd1bbb5cf5196811ce06cb6175a2923d44c83756db2267f6f073/fastapi_toolsets-1.0.0.tar.gz | source | sdist | null | false | c302498847aff55906323121da06d76d | 292915434503ce54f191a39c4014cf1b4b824081eefcd5e3f0d70b8e4803c71e | 841784c78fa6cd1bbb5cf5196811ce06cb6175a2923d44c83756db2267f6f073 | MIT | [
"LICENSE"
] | 240 |
2.4 | sitrep-protocol | 0.0.1 | SITREP: Semantic transport protocol for bandwidth-constrained channels. Name reservation — full release coming soon. | # sitrep-protocol
Semantic transport protocol for bandwidth-constrained channels.
Transmits 16-bit codebook coordinates instead of high-dimensional feature vectors — enabling real-time semantic communication over IoT, satellite, and tactical networks.
## Status
This is a name reservation. The full package is in active development.
## Links
- Website: https://sitrep.vet
- Repository: https://github.com/astronolanX/SITREP.VET
| text/markdown | Nolan Figueroa | null | null | null | Apache-2.0 | semantic communication, codebook, vector quantization, bandwidth constrained, IoT, transport protocol | [
"Development Status :: 1 - Planning",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Scientific/Engineering",
"Topic :: System :: Networking"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://sitrep.vet",
"Repository, https://github.com/astronolanX/SITREP.VET"
] | twine/6.2.0 CPython/3.11.7 | 2026-02-20T14:26:03.388769 | sitrep_protocol-0.0.1.tar.gz | 1,778 | b0/63/9ca7d115e1ea7dd209e13e426fd73684c1623233db2c8b83c300e98d7b8a/sitrep_protocol-0.0.1.tar.gz | source | sdist | null | false | 53a46c295fe6146de120aebc84dfb129 | db488dfedc882f4e37afebd593e4f233dfe837739063d8131a91cb973f7d4a54 | b0639ca7d115e1ea7dd209e13e426fd73684c1623233db2c8b83c300e98d7b8a | null | [] | 223 |
2.4 | ergodic-insurance | 0.13.9 | Financial modeling for widget manufacturers with ergodic insurance limits | # Ergodic Insurance Limits
**What if the cheapest insurance strategy is the one that costs you the most?**
[](https://pypi.org/project/ergodic-insurance/) [](https://alexfiliakov.github.io/Ergodic-Insurance-Limits/) [](https://deepwiki.com/AlexFiliakov/Ergodic-Insurance-Limits)
Traditional insurance analysis asks: *"Does the expected recovery exceed the premium?"* When it doesn't, the recommendation is to self-insure. This framework asks a different question: *"Which strategy maximizes a single company's compound growth over time?"* The answer turns out to be surprisingly different, and it explains why sophisticated buyers routinely pay premiums well above expected losses.
This is a Python simulation framework that applies [ergodic economics](https://ergodicityeconomics.com/) (Ole Peters, 2019) to insurance optimization. It models a business over thousands of simulated timelines to find the insurance structure (retention, limits, layers) that maximizes long-term growth, not just minimizes short-term cost.
> For the general introduction to this research and its business implications, see [mostlyoptimal.com](https://mostlyoptimal.com).
---
## Why Ergodic Economics Matters for Insurance
If you're an actuary, you already understand ruin theory and geometric returns. Ergodic economics provides a unifying framework that connects these ideas to insurance purchasing decisions in a way that expected value analysis cannot.
The core issue is familiar: business wealth compounds multiplicatively. A 50% loss followed by a 50% gain doesn't bring you back to even. It leaves you at 75%. This is the **volatility tax**, and it means large losses destroy more long-term growth than their expected value suggests. Traditional analysis, which averages outcomes *across* many companies at a single point in time (the ensemble average), misses this entirely. What matters for any *single* company is the average outcome *over time* (the time average).
Insurance mitigates this volatility tax. Even when premiums exceed expected losses (sometimes significantly), the reduction in downside variance can result in higher compound growth. The framework precisely quantifies when and by how much.
Practically, this implies there exists an optimal insurance structure for a given risk profile where the growth benefit of variance reduction outweighs the cost of the premium. This framework finds it.
<details>
<summary><strong>The formal relationship</strong></summary>
For multiplicative wealth dynamics, the time-average growth rate is:
$$g = \lim_{T\to\infty}{\frac{1}{T}\ln{\frac{x(T)}{x(0)}}}$$
This is the geometric growth rate: the quantity that actually determines long-term outcomes for a single entity. Optimizing this rate, rather than the expected value $\mathbb{E}[x(T)]$, naturally balances profitability with survival and eliminates the need for arbitrary utility functions or risk preferences.
For a deeper treatment, see the [theory documentation](ergodic_insurance/docs/theory/) or Peters' original paper: [The ergodicity problem in economics](https://doi.org/10.1038/s41567-019-0732-0) (Nature Physics, 2019).
</details>
---
## What This Framework Does
```mermaid
flowchart LR
MODEL["<b>Financial Model</b><br/>Widget Manufacturer<br/>Double-Entry Accounting<br/>Multi-Layer Insurance<br/>Stochastic Loss Processes"]
SIM["<b>Simulation Engine</b><br/>Parallel Monte Carlo<br/>100K+ Paths<br/>Convergence Monitoring"]
ERGODIC["<b>Ergodic Optimization</b><br/>Time-Average vs Ensemble<br/>8 Optimization Algorithms<br/>HJB Optimal Control<br/>Pareto Frontier Analysis"]
OUTPUT["<b>Insights & Reports</b><br/>40+ Visualization Types<br/>VaR, TVaR, Ruin Metrics<br/>Walk-Forward Validation<br/>Excel & HTML Reports"]
MODEL ==> SIM ==> ERGODIC ==> OUTPUT
ERGODIC -.->|"Strategy Refinement"| MODEL
classDef default fill:#f8f9fa,stroke:#dee2e6,stroke-width:2px,color:#212529
classDef hero fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px,color:#1b5e20
class ERGODIC hero
```
The framework models a **widget manufacturer**, a deliberately generic business entity inspired by economics textbooks, through a complete financial simulation with stochastic losses, multi-layer insurance, and double-entry accounting. (The widget manufacturer is the default; contributions to extend the model to other business types are welcome.)
### Ergodic Analysis
- **Time-average vs ensemble-average growth**: the core framework for evaluating insurance decisions
- **Scenario comparison** with statistical significance testing (insured vs uninsured trajectories)
- **Convergence validation** to ensure time-average estimates are reliable
- **Loss-integrated ergodic analysis** connecting loss processes to growth rate impacts
### Monte Carlo Simulation
- **Parallel Monte Carlo engine** with convergence monitoring, checkpointing, and adaptive stopping
- **Bootstrap confidence intervals** for ruin probability and key metrics
- **CPU-optimized parallel execution** designed for budget hardware (4-8 cores, 100K+ simulations in <4GB RAM)
### Financial Modeling
- **Widget manufacturer model** with 75+ methods for revenue, expenses, and balance sheet management
- **Double-entry ledger** with event-sourced accounting and trial balance generation
- **Full financial statements**: balance sheets, income statements, cash flow statements with GAAP compliance
- GAAP compliance is currently a sophisticated approximation, but needs a professional corporate accountant to review
- **Stochastic processes** including geometric Brownian motion, mean-reversion, and lognormal volatility
- **Multi-year claim liability scheduling** with actuarial development patterns and collateral tracking
### Insurance Modeling
- **Multi-layer insurance programs** with attachment points, limits, and reinstatement provisions
- **Market cycle-aware pricing** (soft/normal/hard markets) with cycle transition simulation
- Significant research work is needed on modeling insurance market cycles, **contributors are welcome**
- **Aggregate and per-occurrence limit tracking** with layer utilization monitoring
- **Actuarial claim development** patterns (standard, slow, fast) with cash flow projection
### Optimization
- **8 optimization algorithms** — SLSQP, Differential Evolution, Trust Region, Penalty Method, Augmented Lagrangian, Multi-Start, and more
- **Business outcome optimizer** — maximize ROE, minimize bankruptcy risk, optimize capital efficiency
- **HJB optimal control solver** — stochastic control via Hamilton-Jacobi-Bellman PDE
- **Multi-objective Pareto frontier** generation (weighted-sum, epsilon-constraint, evolutionary methods)
### Risk Metrics & Validation
- **Standard risk metrics** — VaR, TVaR, Expected Shortfall, PML, maximum drawdown, economic capital
- **Ruin probability analysis** with multi-horizon support and bootstrap confidence intervals
- **Walk-forward validation** with out-of-sample testing across rolling windows
- **Strategy backtesting** with pre-built strategies (conservative, aggressive, adaptive, optimized)
### Visualization & Reporting
- **40+ executive and technical plots** — ROE-ruin frontiers, ruin cliffs, tornado diagrams, convergence diagnostics, Pareto frontiers
- **Interactive dashboards** (Plotly-based) for exploration
- **Excel report generation** with cover sheets, financial statements, metrics dashboards, and pivot data
- **45+ Jupyter notebooks** organized by topic for interactive analysis
### Configuration
- **3-tier architecture** — profiles, modules, and presets with inheritance and dot-notation overrides
- **Industry-specific configs** (manufacturing, service, retail) and market condition presets
---
## Reproducible Research
<!--
### [Ergodic Insurance Under Volatility](ergodic_insurance/notebooks/reproducible_research_2026_02_02_basic_volatility/)
Traditional insurance analysis says companies should self-insure whenever premiums exceed expected losses. A 250,000-path Monte Carlo simulation over 50-year horizons shows this advice is **directionally wrong**: the strategy that minimizes expected costs (no insurance) produces the worst actual compound growth, while guaranteed cost insurance achieves the highest growth despite costing the most. The mechanism is the Volatility Tax, where large losses destroy more growth than their expected value suggests because wealth compounds multiplicatively. Without insurance, 37.8% of simulated firms go insolvent; with full coverage, just 0.01% do. The entire experiment is reproducible on Google Colab for ~$25. See the [project README](ergodic_insurance/notebooks/reproducible_research_2026_02_02_basic_volatility/README.md) for setup instructions and parameters to tweak. -->
### [Pareto Frontier Analysis](https://github.com/AlexFiliakov/Ergodic-Insurance-Limits/blob/main/ergodic_insurance/notebooks/optimization/03_pareto_analysis.ipynb)
There is no single “right” deductible for a business.
When you frame insurance purchasing as multi-objective optimization, balancing long-term growth rate against bankruptcy risk, something interesting emerges:
The optimal deductible shifts significantly depending on how much weight the decision-maker places on growth versus safety. Sure, most retentions are strictly dominated (worse on every dimension simultaneously), but there is usually a wide range worth considering.
I built a Pareto frontier experiment for a fictional middle-market manufacturer (\$5M assets, \$10M revenue) using 50,000 Monte Carlo paths. The visualization below shows a decision surface: as you shift from pure ruin minimization (left) to pure growth maximization (right), the black line indicates where the optimal deductible lies.
The “right” retention isn’t a number; it’s a conversation about risk appetite.
### [Pareto Analysis with Sensitivity](https://github.com/AlexFiliakov/Ergodic-Insurance-Limits/blob/main/ergodic_insurance/notebooks/optimization/03_pareto_analysis_with_sensitivity.ipynb)
I built a Pareto frontier experiment for a fictional middle-market manufacturer (\$5M assets, \$10M revenue) using 5,000 Monte Carlo paths across 100 draws from a gamma-distributed large-loss variance. The visualization above shows a decision cloud: as you shift from a high-variability assumption (left) to nearly deterministic losses (right), a valley emerges:
It seems that at the two extremes of loss variability, optimal retention goes up. Why? My guess is that once the losses are nearly deterministic, you might as well retain them and not pay the premium fees. On the other hand, when losses are highly volatile, the impact around the expected value isn’t frequent enough to affect ruin or growth, so all you really need is tail protection.
The bottom line is the “right” retention isn’t a number; it’s a conversation about risk appetite and assumptions.
### [Hamilton-Jacobi-Bellman (HJB) Optimal Control](https://github.com/AlexFiliakov/Ergodic-Insurance-Limits/blob/main/ergodic_insurance/notebooks/optimization/07_hjb_insurance_optimization.ipynb)
This experiment demonstrates that HJB can be a viable mechanism for optimizing long-term retention strategies. While insurance policies are typically bound for one year, HJB facilitates the evaluation of multi-year strategies under dynamic conditions with realistic business constraints.
The main use case I see is evaluating the ROI of a given insurance program when static strategies don’t offer a nuanced long-term view. To make this evaluation more complete, framework enhancements are needed for more realistic insurance market cycles and carrier renewal negotiation strategies, which can be incorporated as additional simulation dynamics. Pull requests are welcome.
### [Optimization Under Volatility](https://github.com/AlexFiliakov/Ergodic-Insurance-Limits/blob/main/ergodic_insurance/notebooks/optimization/03_pareto_analysis_with_loss_and_vol_sens.ipynb)
In my next experiment, I explore optimal deductibles under two volatility assumptions: operational volatility and loss volatility. I set up a deductible optimizer with two objectives: maximize growth while minimizing growth volatility (did you think I'd run out of volatilities to analyze?).
I also added a constraint: risk of ruin cannot exceed 1%. To give us a nice fat tail, I set inverse Gaussian Bayesian priors on the volatility assumptions.
That's right: inverse Gaussian Bayesian priors on the loss Pareto alpha, plotted in Euclidean space with Lanczos interpolation. I hope that's enough name-dropping for one post.
No Hamilton-Jacobi-Bellman this time. I showed restraint.
Above is a heatmap of the results. The findings reinforce the last experiment, but the setup is more flexible, and honestly, it was just fun to build.
### Blog Posts
- [Ergodic Insurance Part 1: From Cost Center to Growth Engine: When N=1](https://medium.com/@alexfiliakov/ergodic-insurance-part-1-from-cost-center-to-growth-engine-when-n-1-52c17b048a94)
- [Insurance Limit Selection Through Ergodicity: When the 99.9th Percentile Isn't Enough](https://applications.mostlyoptimal.com/insurance-limit-selection-through-ergodicity-when-the-99p9th-percentile-isnt-enough)
- [Beyond Point Estimates: Stochasticizing Tail Uncertainty With Sobol Sequences](https://applications.mostlyoptimal.com/stochasticizing-tail-risk)
- [The Insurance Cliff: Where Small Decisions Create Catastrophic Outcomes](https://applications.mostlyoptimal.com/insurance-cliff-by-risk-profile)
---
## Quick Start
### Install
```bash
pip install ergodic-insurance
```
Requires Python 3.12+. For optional features: `pip install ergodic-insurance[excel]` (Excel reports).
### Run Your First Analysis
```python
from ergodic_insurance import run_analysis
results = run_analysis(
initial_assets=10_000_000,
loss_frequency=2.5,
loss_severity_mean=1_000_000,
deductible=500_000,
coverage_limit=10_000_000,
premium_rate=0.025,
n_simulations=1000,
time_horizon=20,
)
print(results.summary()) # human-readable comparison
results.plot() # 2x2 insured-vs-uninsured chart
df = results.to_dataframe() # per-simulation metrics
```
### Verify Installation
```python
from ergodic_insurance import run_analysis
results = run_analysis(n_simulations=5, time_horizon=5, seed=42)
print(results.summary())
print("Installation successful!")
```
### Explore Further
| Notebook | Topic |
|---|---|
| [Setup Verification](ergodic_insurance/notebooks/getting-started/01_setup_verification.ipynb) | Confirm your environment works |
| [Quick Start](ergodic_insurance/notebooks/getting-started/02_quick_start.ipynb) | First simulation walkthrough |
| [Ergodic Advantage](ergodic_insurance/notebooks/core/03_ergodic_advantage.ipynb) | Time-average vs ensemble-average demonstration |
| [Monte Carlo Simulation](ergodic_insurance/notebooks/core/04_monte_carlo_simulation.ipynb) | Deep dive into the simulation engine |
| [Risk Metrics](ergodic_insurance/notebooks/core/05_risk_metrics.ipynb) | VaR, TVaR, ruin probability analysis |
| [Retention Optimization](ergodic_insurance/notebooks/optimization/04_retention_optimization.ipynb) | Finding optimal deductibles |
| [HJB Optimal Control](ergodic_insurance/notebooks/advanced/01_hjb_optimal_control.ipynb) | Theoretical optimal control benchmarks |
See the [full documentation](https://alexfiliakov.github.io/Ergodic-Insurance-Limits/) or the [Getting Started tutorial](https://docs.mostlyoptimal.com/tutorials/01_getting_started.html) for more.
---
## Professional Standards and Disclaimers
This framework provides actuarial research tools subject to [ASOP No. 41: Actuarial Communications](https://www.actuarialstandardsboard.org/asops/actuarial-communications/) and [ASOP No. 56: Modeling](http://www.actuarialstandardsboard.org/asops/modeling-3/). Full compliance disclosures are in the [Actuarial Standards Compliance](ergodic_insurance/docs/user_guide/actuarial_standards.rst) document.
**Research Use Only.** This is an early-stage research tool. It does not constitute an actuarial opinion or rate filing. Outputs are intended for qualified actuaries who can independently validate the methodology and results.
**Responsible Actuary:** Alex Filiakov, ACAS. Review is ongoing; the responsible actuary does not currently take responsibility for the accuracy of the methodology or results.
<details>
<summary><strong>Key Limitations & Disclosures</strong></summary>
- Outputs should not be used for regulatory filings, rate opinions, or reserve opinions without independent actuarial analysis.
- Results are illustrative and depend on input assumptions. Treat them as directional guidance, not prescriptive recommendations.
- The framework embeds simplifying assumptions (Poisson frequency, log-normal severity, no regulatory capital, deterministic margins) documented in the compliance disclosures.
- Development involved extensive reliance on Large Language Models for research and code generation.
- **Conflict of Interest:** The responsible actuary is employed by an insurance broker. See the compliance document for full disclosure and mitigation measures.
</details>
---
## Contributing
This project is in active development (pre-1.0) and there is meaningful work to be done. Whether you're an experienced actuary who can stress-test the methodology or a developer who can tackle implementation issues, contributions are welcome.
### Where to Start
- **[Open Issues](https://github.com/AlexFiliakov/Ergodic-Insurance-Limits/issues)** — 30 open issues spanning mathematical correctness, actuarial methodology, and security hardening. Many are well-scoped and self-contained.
- **[Codebase Onboarding Guide](docs/Codebase%20Onboarding%20Guide.md)** — A structured walkthrough of the key concepts, domain terms, and architecture. Start here before diving into the code.
- **[DeepWiki](https://deepwiki.com/AlexFiliakov/Ergodic-Insurance-Limits)** — AI-powered Q&A over the entire codebase. Useful for navigating 74 modules without reading all of them.
### Areas Where Help Is Needed
| Area | Examples | Good For |
|---|---|---|
| **Mathematical correctness** | Variance corrections, bias adjustments, convergence estimators | Actuaries, statisticians, quantitative researchers |
| **Actuarial methodology** | Claim reserve re-estimation, development pattern calibration, bootstrap CI improvements | Practicing actuaries, CAS/SOA candidates |
| **New business models** | Extending beyond the widget manufacturer to service, retail, or other industry types | Domain experts in other industries |
| **Optimization & theory** | HJB solver improvements, new objective functions, multi-period strategies | Applied mathematicians, operations researchers |
| **Testing & validation** | Walk-forward validation, convergence diagnostics, edge case coverage | Anyone comfortable with pytest |
### Developer Setup
```bash
git clone https://github.com/AlexFiliakov/Ergodic-Insurance-Limits.git
cd Ergodic-Insurance-Limits
python ergodic_insurance/scripts/setup_dev.py
```
This installs the package in editable mode with dev dependencies and configures pre-commit hooks (black, isort, mypy, pylint, conventional commits). Or manually:
```bash
pip install -e ".[dev]"
pre-commit install
pre-commit install --hook-type commit-msg
```
### Running Tests
```bash
pytest # all tests with coverage
pytest ergodic_insurance/tests/test_manufacturer.py # specific module
pytest --cov=ergodic_insurance --cov-report=html # HTML coverage report
```
### Branch Strategy
- **`main`** — stable releases only, protected
- **`develop`** — integration branch, PRs go here
- Use conventional commit messages (`feat:`, `fix:`, `docs:`, etc.) — this drives automated versioning
---
## Project Structure
```
Ergodic-Insurance-Limits/
├── ergodic_insurance/ # Main Python package (74 modules)
│ ├── manufacturer.py # Widget manufacturer financial model
│ ├── simulation.py # Simulation orchestrator
│ ├── monte_carlo.py # Parallel Monte Carlo engine
│ ├── ergodic_analyzer.py # Time-average growth analysis
│ ├── insurance.py # Insurance structures and layers
│ ├── insurance_program.py # Multi-layer program management
│ ├── insurance_pricing.py # Premium calculation models
│ ├── loss_distributions.py # Statistical loss modeling (lognormal, Pareto, etc.)
│ ├── optimization.py # Optimization algorithms and solvers
│ ├── business_optimizer.py # Business outcome optimization
│ ├── hjb_solver.py # Hamilton-Jacobi-Bellman optimal control
│ ├── pareto_frontier.py # Multi-objective Pareto analysis
│ ├── risk_metrics.py # VaR, TVaR, ruin probability
│ ├── financial_statements.py # GAAP-compliant financial statements
│ ├── stochastic_processes.py # GBM, mean-reversion, volatility models
│ ├── parallel_executor.py # CPU-optimized parallel processing
│ ├── gpu_mc_engine.py # GPU-accelerated Monte Carlo (CuPy)
│ ├── walk_forward_validator.py # Walk-forward validation framework
│ ├── strategy_backtester.py # Insurance strategy backtesting
│ ├── convergence.py # Convergence diagnostics
│ ├── bootstrap_analysis.py # Bootstrap statistical methods
│ ├── sensitivity.py # Sensitivity analysis
│ ├── config/ # 3-tier configuration system
│ │ ├── core.py # Config classes and validation
│ │ ├── presets.py # Market condition templates
│ │ └── ... # Insurance, manufacturer, simulation configs
│ ├── reporting/ # Report generation
│ │ ├── executive_report.py # Executive-level summaries
│ │ ├── technical_report.py # Technical analysis reports
│ │ ├── insight_extractor.py # Automated insight extraction
│ │ └── ... # Excel, tables, scenario comparison
│ ├── visualization/ # Plotting (executive, technical, interactive)
│ ├── notebooks/ # 45+ Jupyter notebooks
│ │ ├── getting-started/ # Setup and first steps
│ │ ├── core/ # Loss distributions, insurance, ergodic advantage
│ │ ├── optimization/ # Retention, Pareto, sensitivity, parameter sweeps
│ │ ├── advanced/ # HJB control, walk-forward, convergence
│ │ ├── reconciliation/ # 10 validation and reconciliation notebooks
│ │ ├── visualization/ # Dashboards, plots, scenario comparison
│ │ ├── reporting/ # Report and table generation
│ │ └── research/ # Exploratory research notebooks
│ ├── tests/ # 60+ test modules
│ ├── examples/ # Demo scripts
│ ├── data/config/ # YAML configuration profiles and presets
│ ├── docs/ # Sphinx documentation (API, tutorials, theory)
│ └── scripts/ # Setup and utility scripts
├── assets/ # Images and visual resources
├── docs/ # GitHub Pages documentation
├── .github/workflows/ # CI/CD pipelines
├── pyproject.toml # Project configuration and dependencies
├── CHANGELOG.md # Release history
└── LICENSE # MIT
```
---
## License
MIT. See [LICENSE](LICENSE).
| text/markdown | null | Alex Filiakov <alexfiliakov@gmail.com> | null | null | null | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Mathematics",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"numpy>=2.3.2",
"pandas<3.0,>=2.3.2",
"pydantic>=2.11.7",
"pyyaml>=6.0.2",
"matplotlib>=3.10.5",
"seaborn>=0.13.2",
"scipy>=1.16.1",
"joblib>=1.3.2",
"tqdm>=4.66.1",
"pyarrow>=14.0.1",
"h5py>=3.9.0",
"psutil>=5.9.0",
"plotly>=5.18.0",
"jinja2>=3.1.0",
"reportlab>=4.2.5",
"markdown2>=2.5.2",
"tabulate>=0.9.0",
"rich>=13.0.0",
"weasyprint>=64.0; extra == \"pdf\"",
"xlsxwriter>=3.1.0; extra == \"excel\"",
"openpyxl>=3.1.0; extra == \"excel\"",
"cupy-cuda12x>=13.0.0; extra == \"gpu\"",
"pytest>=8.4.1; extra == \"dev\"",
"pytest-cov>=6.2.1; extra == \"dev\"",
"coverage>=7.7.0; extra == \"dev\"",
"pytest-xdist>=3.8.0; extra == \"dev\"",
"pytest-timeout>=2.3.1; extra == \"dev\"",
"pylint>=3.3.8; extra == \"dev\"",
"black>=25.1.0; extra == \"dev\"",
"mypy>=1.17.1; extra == \"dev\"",
"isort>=6.0.1; extra == \"dev\"",
"types-PyYAML>=6.0.0; extra == \"dev\"",
"types-tabulate>=0.9.0; extra == \"dev\"",
"pre-commit>=3.6.0; extra == \"dev\"",
"hypothesis>=6.100.0; extra == \"dev\"",
"xlsxwriter>=3.1.0; extra == \"dev\"",
"openpyxl>=3.1.0; extra == \"dev\"",
"sphinx>=8.2.3; extra == \"docs\"",
"sphinx-rtd-theme>=3.0.2; extra == \"docs\"",
"sphinx-autodoc-typehints>=3.2.0; extra == \"docs\"",
"myst-parser>=4.0.1; extra == \"docs\"",
"sphinx-copybutton>=0.5.2; extra == \"docs\"",
"sphinxcontrib-mermaid>=1.0.0; extra == \"docs\"",
"jupyter>=1.1.1; extra == \"notebooks\"",
"notebook>=7.4.5; extra == \"notebooks\"",
"ipykernel>=6.30.1; extra == \"notebooks\"",
"nbformat>=5.10.4; extra == \"notebooks\""
] | [] | [] | [] | [
"Homepage, https://github.com/AlexFiliakov/Ergodic-Insurance-Limits",
"Repository, https://github.com/AlexFiliakov/Ergodic-Insurance-Limits",
"Issues, https://github.com/AlexFiliakov/Ergodic-Insurance-Limits/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:25:47.335153 | ergodic_insurance-0.13.9.tar.gz | 1,601,335 | a2/b2/5e6ea2a0b38ea0b44040fa443b7302fb40b85a6cbda7eea209c21ccc3e93/ergodic_insurance-0.13.9.tar.gz | source | sdist | null | false | 7a35c3e059af4c50c6c1711c6917a6cb | 925901f8394a24b073c2786e620403abf21f397f857f352434057bbc2fc7c878 | a2b25e6ea2a0b38ea0b44040fa443b7302fb40b85a6cbda7eea209c21ccc3e93 | null | [
"LICENSE"
] | 227 |
2.4 | az-scout | 2026.2.7 | Azure SKU scout — explore availability zones, capacity, pricing, and plan VM deployments across subscriptions | # Azure Scout: `az-scout`
[](https://github.com/lrivallain/az-scout/actions/workflows/ci.yml)
[](https://github.com/lrivallain/az-scout/actions/workflows/publish.yml)
[](https://github.com/lrivallain/az-scout/actions/workflows/container.yml)
[](https://pypi.org/project/az-scout/)
[](https://pypi.org/project/az-scout/)
[](LICENSE.txt)
Scout Azure regions for VM availability, zone mappings, pricing, spot scores, and quota — then plan deployments with confidence.
> **az-scout** helps you compare how Azure maps logical Availability Zones to physical zones across subscriptions, evaluate SKU capacity and pricing, and generate deterministic deployment plans — all from a single web UI or MCP-powered AI agent.
## Features
- **Logical-to-physical zone mapping** – visualise how Azure maps logical Availability Zones (Zone 1, Zone 2, Zone 3) to physical zones (e.g., eastus-az1, eastus-az2) across subscriptions in a region.
- **SKU availability view** – shows VM SKU availability per physical zone with vCPU quota usage (limit / used / remaining) and CSV export.
- **Spot Placement Scores** – evaluate the likelihood of Spot VM allocation (High / Medium / Low) per SKU for a given region and instance count, powered by the Azure Compute RP.
- **Deployment Confidence Score** – a composite 0–100 score per SKU estimating deployment success probability, synthesised from quota headroom, Spot Placement Score, availability zone breadth, restrictions, and price pressure signals. Missing signals are automatically excluded with weight renormalisation. The score updates live when Spot Placement Scores arrive.
- **Deployment Plan** – agent-ready `POST /api/deployment-plan` endpoint that evaluates (region, SKU) combinations against zones, quotas, spot scores, pricing, and restrictions. Returns a deterministic, ranked plan with business and technical views (no LLM, no invention — missing data is flagged explicitly).
- **MCP server** – expose all capabilities as MCP tools for AI agents (see below).
## Quick start
### Prerequisites
| Requirement | Details |
|---|---|
| Python | ≥ 3.11 |
| Azure credentials | Any method supported by `DefaultAzureCredential` (`az login`, managed identity, …) |
| RBAC | **Reader** on the subscriptions you want to query, **Virtual Machine Contributor** on the subscriptions for Spot Placement Scores retrieval |
### Run locally with `uv` tool (recommended)
```bash
# Make sure you are authenticated to Azure
az login
# Run the tool (no install required)
uvx az-scout
```
Your browser opens automatically at `http://127.0.0.1:5001`.
## Installation options
### Recommended: install with `uv`
```bash
uv install az-scout
uvx az-scout
```
### Alternative: install with `pip`
```bash
pip install az-scout
az-scout
```
### Docker
```bash
docker run --rm -p 8000:8000 \
-e AZURE_TENANT_ID=<your-tenant> \
-e AZURE_CLIENT_ID=<your-sp-client-id> \
-e AZURE_CLIENT_SECRET=<your-sp-secret> \
ghcr.io/lrivallain/az-scout:latest
```
### Azure Container App
It is also possible to deploy az-scout as a web app in Azure using the provided Bicep template (see [Deploy to Azure](#deploy-to-azure-container-app) section below).
**Note:** The web UI is designed for local use and may **not be suitable for public-facing deployment without additional security measures** (authentication, network restrictions, etc.). The MCP server can be exposed over the public internet if needed, but ensure you have proper authentication and authorization in place to protect access to Azure data.
#### UI guided deployment
[](https://portal.azure.com/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2Flrivallain%2Faz-scout%2Fmain%2Fdeploy%2Fmain.json/createUIDefinitionUri/https%3A%2F%2Fraw.githubusercontent.com%2Flrivallain%2Faz-scout%2Fmain%2Fdeploy%2FcreateUiDefinition.json)
A Bicep template is provided to deploy az-scout as an Azure Container App with a managed identity.
You can use the **Deploy to Azure** button above for a portal-guided experience, or use the CLI commands below.
#### Bicep deploy from CLI
```bash
# Create a resource group
az group create -n rg-az-scout -l <your-region>
# Deploy (replace subscription IDs with your own)
az deployment group create \
-g rg-az-scout \
-f deploy/main.bicep \
-p readerSubscriptionIds='["SUB_ID_1","SUB_ID_2"]'
```
See [`deploy/main.example.bicepparam`](deploy/main.example.bicepparam) for all available parameters.
#### Resources created
The deployment creates:
| Resource | Purpose |
|---|---|
| **Container App** | Runs `ghcr.io/lrivallain/az-scout` |
| **Managed Identity** | `Reader` role on target subscriptions |
| **VM Contributor** | `Virtual Machine Contributor` role for Spot Placement Scores (enabled by default) |
| **Log Analytics** | Container logs and diagnostics |
| **Container Apps Env** | Hosting environment |
> **Note:** The `Virtual Machine Contributor` role is required for querying Spot Placement Scores (POST endpoint). Set `enableSpotScoreRole=false` to skip this if you don't need spot scores or prefer to manage permissions manually.
#### Enable Entra ID authentication (EasyAuth)
For a complete walkthrough (App Registration creation, client secret, user assignment, troubleshooting), see [`deploy/EASYAUTH.md`](deploy/EASYAUTH.md).
## Usage
### CLI options
```bash
az-scout [COMMAND] [OPTIONS]
az-scout --help. # show global help
az-scout web --help # show web subcommand help
az-scout mcp --help # show mcp subcommand help
az-scout --version # show version
```
#### `az-scout web` (default)
Run the web UI. This is the default when no subcommand is given.
```
--host TEXT Host to bind to. [default: 127.0.0.1]
--port INTEGER Port to listen on. [default: 5001]
--no-open Don't open the browser automatically.
-v, --verbose Enable verbose logging.
--reload Auto-reload on code changes (development only).
--help Show this message and exit.
```
#### `az-scout mcp`
Run the MCP server.
```
--http Use Streamable HTTP transport instead of stdio.
--port INTEGER Port for Streamable HTTP transport. [default: 8080]
-v, --verbose Enable verbose logging.
--help Show this message and exit.
```
### MCP server
An [MCP](https://modelcontextprotocol.io/) server is included, allowing AI agents (Claude Desktop, VS Code Copilot, etc.) to query zone mappings and SKU availability directly.
#### Available tools
| Tool | Description |
|---|---|
| `list_tenants` | Discover Azure AD tenants and authentication status |
| `list_subscriptions` | List enabled subscriptions (optionally scoped to a tenant) |
| `list_regions` | List regions that support Availability Zones |
| `get_zone_mappings` | Get logical→physical zone mappings for subscriptions in a region |
| `get_sku_availability` | Get VM SKU availability per zone with restrictions, capabilities, and vCPU quota per family |
| `get_spot_scores` | Get Spot Placement Scores (High / Medium / Low) for a list of VM sizes in a region |
| `get_sku_pricing_detail` | Get detailed Linux pricing (PayGo, Spot, RI 1Y/3Y, SP 1Y/3Y) and VM profile for a single SKU |
`get_sku_availability` supports optional filters to reduce output size:
`name`, `family`, `min_vcpus`, `max_vcpus`, `min_memory_gb`, `max_memory_gb`.
#### stdio transport (default – for Claude Desktop, VS Code, etc.)
```bash
az-scout mcp
```
Add to your MCP client configuration:
```json
{
"mcpServers": {
"az-scout": {
"command": "az-scout",
"args": ["mcp"]
}
}
}
```
If using `uv`:
```json
{
"mcpServers": {
"az-scout": {
"command": "uvx",
"args": ["az-scout", "mcp"]
}
}
}
```
#### Streamable HTTP transport
When running in `web` mode, the MCP server is automatically available at `/mcp` for integration with web-based clients or when running as a hosted deployment (Container App, etc.).
For **MCP-only** use with Streamable HTTP transport, run:
```bash
az-scout mcp --http --port 8082
```
Add to your MCP client configuration:
```json
{
"mcpServers": {
"az-scout": {
"url": "http://localhost:8082/mcp" // or "https://<your-app-url>/mcp" for web command
}
}
}
```
> **Hosted deployment:** When running as a Container App (or any hosted web server), the MCP endpoint is automatically available at `/mcp` alongside the web UI — no separate server needed. Point your MCP client to `https://<your-app-url>/mcp`.
>
> **EasyAuth:** If your Container App has EasyAuth enabled, MCP clients must pass a bearer token in the `Authorization` header. See the [EasyAuth guide](deploy/EASYAUTH.md#7-connect-mcp-clients-through-easyauth) for detailed instructions.
### API
API documentation is available at `/docs` (Swagger UI) and `/redoc` (ReDoc) when the server is running.
### Deployment Plan API
The `POST /api/deployment-plan` endpoint provides a deterministic decision engine for deployment planning. It is designed for Sales / Solution Engineers and AI agents: no LLM is involved — every decision traces back to real Azure data.
#### Request
```json
{
"subscriptionId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"regionConstraints": {
"allowRegions": ["francecentral", "westeurope"],
"dataResidency": "EU"
},
"skuConstraints": {
"preferredSkus": ["Standard_D2s_v3", "Standard_E8s_v4"],
"requireZonal": true
},
"scale": { "instanceCount": 4 },
"pricing": {
"currencyCode": "EUR",
"preferSpot": true,
"maxHourlyBudget": 2.0
},
"timing": { "urgency": "now" }
}
```
#### Response (abbreviated)
```json
{
"summary": {
"recommendedRegion": "francecentral",
"recommendedSku": "Standard_D2s_v3",
"recommendedMode": "zonal",
"riskLevel": "low",
"confidenceScore": 85
},
"businessView": {
"keyMessage": "Standard_D2s_v3 in francecentral is recommended ...",
"reasons": ["Available in 3 availability zone(s).", "Sufficient quota ..."],
"risks": [],
"mitigations": [],
"alternatives": [{ "region": "westeurope", "sku": "Standard_E8s_v4", "reason": "..." }]
},
"technicalView": {
"evaluation": { "regionsEvaluated": ["francecentral", "westeurope"], "perRegionResults": [] },
"dataProvenance": { "evaluatedAt": "...", "cacheTtl": {}, "apiVersions": {} }
},
"warnings": ["Spot placement score is probabilistic and not a guarantee."],
"errors": []
}
```
> **Note:** Spot placement scores are probabilistic and not a guarantee of allocation. Quota values are dynamic and may change between planning and actual deployment.
## Under the hood
The backend calls the Azure Resource Manager REST API to fetch:
- **Zone mappings**: `availabilityZoneMappings` from `/subscriptions/{id}/locations` endpoint
- **Resource SKUs**: SKU details from `/subscriptions/{id}/providers/Microsoft.Compute/skus` endpoint with zone restrictions and capabilities
- **Compute Usages**: vCPU quota per VM family from `/subscriptions/{id}/providers/Microsoft.Compute/locations/{region}/usages` endpoint (cached for 10 minutes, with retry on throttling and graceful handling of 403)
- **Spot Placement Scores**: likelihood indicators for Spot VM allocation from `/subscriptions/{id}/providers/Microsoft.Compute/locations/{region}/placementScores/spot/generate` endpoint (batched in chunks of 100, sequential execution with retry/back-off, cached for 10 minutes). Note: these scores reflect the probability of obtaining a Spot VM allocation, not datacenter capacity.
## License
[MIT](LICENSE.txt)
| text/markdown | Ludovic Rivallain | null | null | null | MIT | availability-zone, azure, mapping, visualization | [
"Development Status :: 4 - Beta",
"Environment :: Web Environment",
"Framework :: FastAPI",
"Intended Audience :: System Administrators",
"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 :: System :: Systems Administration"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"azure-identity>=1.15",
"click>=8.1",
"fastapi>=0.115",
"jinja2>=3.1",
"mcp[cli]>=1.9",
"requests>=2.31",
"uvicorn[standard]>=0.34"
] | [] | [] | [] | [
"Homepage, https://github.com/lrivallain/az-scout",
"Repository, https://github.com/lrivallain/az-scout",
"Issues, https://github.com/lrivallain/az-scout/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:24:50.057095 | az_scout-2026.2.7.tar.gz | 209,425 | 70/3a/ba4ee629f90ef60aebcdbddf2fdd3838e0ff55154fb142060702124ced31/az_scout-2026.2.7.tar.gz | source | sdist | null | false | e6689ac14397bd230a00b2ae936dc6a6 | bba5cfae3c6289eb5c05ef088e6e652c665fdf8dcf9b99f0ecf09ab54e358b7d | 703aba4ee629f90ef60aebcdbddf2fdd3838e0ff55154fb142060702124ced31 | null | [
"LICENSE.txt"
] | 209 |
2.4 | autonomize-observer | 2.0.10 | Unified LLM Observability & Audit SDK - thin wrapper around Pydantic Logfire with Keycloak and Kafka support | # Autonomize Observer SDK
[](https://badge.fury.io/py/autonomize-observer)
[](https://pypi.org/project/autonomize-observer/)
[](LICENSE)
[](tests/)
A lightweight, production-ready SDK for LLM observability and audit logging. Built as a thin wrapper around [Pydantic Logfire](https://logfire.pydantic.dev/) for tracing and [genai-prices](https://github.com/jetify-com/genai-prices) for cost calculation, with additional support for:
- **Audit Logging** - Compliance-ready audit trails with Keycloak JWT integration
- **Kafka Export** - Stream audit events to Kafka for downstream processing
- **Langflow Integration** - First-class support for Langflow/Flow tracing
- **FastAPI Middleware** - Automatic user context extraction from JWT tokens
## Why Autonomize Observer?
Instead of reinventing the wheel, we leverage best-in-class libraries:
| Feature | Powered By |
|---------|------------|
| OTEL Tracing & Spans | [Pydantic Logfire](https://logfire.pydantic.dev/) |
| OpenAI/Anthropic Instrumentation | [Logfire Integrations](https://logfire.pydantic.dev/docs/integrations/) |
| LLM Cost Calculation | [genai-prices](https://github.com/jetify-com/genai-prices) (28+ providers) |
| Audit Logging & Keycloak | **Autonomize Observer** |
| Kafka Event Export | **Autonomize Observer** |
| Langflow Integration | **Autonomize Observer** |
## Quick Start
### Installation
```bash
# Using pip
pip install autonomize-observer
# Using uv (recommended)
uv add autonomize-observer
```
### Basic Usage
```python
from autonomize_observer import init, audit
from autonomize_observer import ResourceType
# Initialize once at startup
init(
service_name="my-service",
kafka_enabled=False, # Enable for Kafka export
)
# Log audit events
audit.log_create(
resource_type=ResourceType.DOCUMENT,
resource_id="doc-123",
resource_name="Project Proposal",
)
# Log LLM interactions for compliance
audit.log_llm_interaction(
flow_id="flow-456",
model="gpt-4o",
provider="openai",
input_tokens=150,
output_tokens=75,
cost=0.025,
)
```
### LLM Tracing with Logfire
For LLM tracing, use Logfire directly - we don't duplicate its functionality:
```python
import logfire
from openai import OpenAI
# Configure Logfire (data stays local by default)
logfire.configure(
service_name="my-service",
send_to_logfire=False, # Keep data local
)
# One-line instrumentation for all OpenAI calls
logfire.instrument_openai()
# Use OpenAI normally - all calls are traced
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hello!"}]
)
```
### Cost Calculation
```python
from autonomize_observer import calculate_cost, get_price
# Calculate cost for an LLM call
result = calculate_cost(
provider="openai",
model="gpt-4o",
input_tokens=1000,
output_tokens=500,
)
print(f"Total cost: ${result.total_cost:.4f}")
print(f"Input cost: ${result.input_cost:.4f}")
print(f"Output cost: ${result.output_cost:.4f}")
# Get price info for a model
price = get_price("anthropic", "claude-3-5-sonnet-20241022")
if price:
print(f"Input: ${price.input_price_per_1k:.4f}/1K tokens")
print(f"Output: ${price.output_price_per_1k:.4f}/1K tokens")
```
## Key Features
### Audit Logging with Keycloak Support
```python
from autonomize_observer import (
init, audit,
ActorContext, set_actor_context,
ResourceType, AuditAction,
)
# Set user context from Keycloak JWT
set_actor_context(ActorContext(
actor_id="user-123",
email="user@example.com",
roles=["admin", "analyst"],
))
# All audit events now include user context
audit.log_read(
resource_type=ResourceType.FILE,
resource_id="sensitive-data.csv",
)
audit.log_update(
resource_type=ResourceType.USER,
resource_id="user-456",
changes=[
{"field": "role", "old_value": "viewer", "new_value": "editor"},
],
)
```
### Kafka Export for Audit Events
```python
from autonomize_observer import init, KafkaConfig
init(
service_name="my-service",
kafka_config=KafkaConfig(
bootstrap_servers="kafka:9092",
audit_topic="audit-events",
security_protocol="SASL_SSL",
sasl_mechanism="PLAIN",
sasl_username="user",
sasl_password="secret",
),
kafka_enabled=True,
)
# All audit events are now streamed to Kafka
```
### Langflow Integration
```python
from autonomize_observer.integrations import trace_flow, trace_component
@trace_flow(
flow_id="customer-support-flow",
flow_name="Customer Support Bot",
session_id="session-123",
)
def run_customer_support(query: str) -> str:
# Flow execution is automatically traced
@trace_component("LLMComponent", "Query Analyzer")
def analyze_query():
# Component execution is traced as a child span
return process_with_llm(query)
@trace_component("LLMComponent", "Response Generator")
def generate_response(analysis):
return generate_with_llm(analysis)
analysis = analyze_query()
return generate_response(analysis)
```
### FastAPI Integration
```python
from fastapi import FastAPI
from autonomize_observer.integrations import setup_fastapi
app = FastAPI()
# Automatically extracts user context from JWT tokens
setup_fastapi(
app,
service_name="my-api",
keycloak_enabled=True,
)
@app.get("/documents/{doc_id}")
async def get_document(doc_id: str):
# User context is automatically available for audit logging
from autonomize_observer import audit, ResourceType
audit.log_read(
resource_type=ResourceType.DOCUMENT,
resource_id=doc_id,
)
return {"id": doc_id, "content": "..."}
```
## Workflow Tracing
For transactional workflows that need step-by-step timing (not LLM-specific):
```python
from autonomize_observer.tracing import WorkflowTracer
with WorkflowTracer("process-order", order_id="123") as tracer:
with tracer.step("validate") as step:
validate_order()
step.set("items_count", 5)
with tracer.step("payment") as step:
result = process_payment()
step.set("amount", result.amount)
with tracer.step("fulfillment"):
send_to_warehouse()
tracer.set("status", "completed")
# Access timing data
for step in tracer.steps:
print(f"{step.name}: {step.duration_ms:.2f}ms")
```
## Agent Tracing
The SDK provides two approaches for tracing agents/LLM workflows:
### Standalone Agent Tracing (Recommended for new projects)
Use Logfire directly for modern OTEL-based tracing:
```python
import logfire
from openai import OpenAI
# Configure Logfire (one-time setup)
logfire.configure(
service_name="my-agent",
send_to_logfire=False, # Keep data local or send to your OTEL collector
)
# Auto-instrument LLM clients
logfire.instrument_openai()
logfire.instrument_anthropic()
# Use normally - all LLM calls are automatically traced with token usage
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hello!"}]
)
```
### AI Studio Integration (Legacy streaming format)
For AI Studio (Langflow) compatibility, use `AgentTracer`:
```python
from uuid import uuid4
from autonomize_observer.tracing import AgentTracer
# Create tracer with Kafka streaming
tracer = AgentTracer(
trace_name="Customer Support Flow",
trace_id=uuid4(),
flow_id="flow-123",
kafka_bootstrap_servers="kafka:9092",
kafka_topic="genesis-traces-streaming",
# Optional: Enable dual export (Kafka + OTEL)
enable_otel=True,
)
# Trace workflow
tracer.start_trace()
tracer.add_trace("comp-1", "QueryAnalyzer", "llm", {"query": "..."})
# ... component execution ...
tracer.end_trace("comp-1", "QueryAnalyzer", {"result": "..."})
tracer.end(inputs={}, outputs={})
```
## Architecture
### SDK Components
```mermaid
graph TB
subgraph SDK["Autonomize Observer SDK"]
subgraph Core["core/"]
Config[KafkaConfig<br/>ObserverConfig]
Imports[imports.py<br/>Availability checks]
end
subgraph Tracing["tracing/"]
AT[AgentTracer]
WT[WorkflowTracer]
Factory[TracerFactory]
OTEL[OTELManager]
end
subgraph Audit["audit/"]
Logger[AuditLogger]
Context[ActorContext]
end
subgraph Exporters["exporters/"]
KafkaExp[KafkaExporter]
KafkaBase[BaseKafkaProducer]
end
subgraph Cost["cost/"]
Pricing[calculate_cost<br/>get_price]
end
subgraph Integrations["integrations/"]
FastAPI[FastAPI Middleware]
Langflow[Flow Tracing]
end
end
Tracing --> Core
Audit --> Core
Exporters --> Core
Integrations --> Tracing
Integrations --> Audit
```
### Data Flow
```mermaid
flowchart LR
subgraph App["Your Application"]
LLM[LLM Calls]
WF[Workflows]
API[API Requests]
end
subgraph SDK["Autonomize Observer"]
AT[AgentTracer]
WT[WorkflowTracer]
AL[AuditLogger]
LF[Logfire]
end
subgraph Export["Export Destinations"]
K[Kafka]
OT[OTEL Collector]
LFD[Logfire Dashboard]
end
LLM --> LF
LLM --> AT
WF --> WT
API --> AL
AT --> K
AT --> OT
WT --> K
WT --> OT
AL --> K
LF --> OT
LF --> LFD
```
### Class Hierarchy
```mermaid
classDiagram
class BaseTracer {
<<protocol>>
+start()
+end(outputs)
+__enter__()
+__exit__()
}
class TracerMixin {
+set(key, value)
+get_summary()
}
class AgentTracer {
+trace_id: UUID
+flow_id: str
+start_trace()
+add_trace()
+end_trace()
}
class WorkflowTracer {
+name: str
+steps: list
+step(name)
+duration_ms
}
class TracerFactory {
+config: ObserverConfig
+create_agent_tracer()
+create_workflow_tracer()
}
BaseTracer <|.. AgentTracer
BaseTracer <|.. WorkflowTracer
TracerMixin <|-- AgentTracer
TracerMixin <|-- WorkflowTracer
TracerFactory --> AgentTracer
TracerFactory --> WorkflowTracer
```
### Directory Structure
<details>
<summary>Click to expand file tree</summary>
```
autonomize-observer/
├── audit/ # Audit logging with Keycloak support
│ ├── context.py # ActorContext and JWT parsing
│ └── logger.py # AuditLogger with convenience methods
├── core/ # Shared utilities and configuration
│ ├── config.py # KafkaConfig, ObserverConfig
│ ├── imports.py # Centralized dependency availability checks
│ └── kafka_utils.py # Shared Kafka config builder
├── cost/ # Cost calculation (wraps genai-prices)
│ └── pricing.py # calculate_cost, get_price
├── exporters/ # Event export (Kafka)
│ ├── base.py # BaseExporter interface
│ ├── kafka_base.py # BaseKafkaProducer (shared Kafka logic)
│ └── kafka.py # KafkaExporter for audit events
├── integrations/ # Framework integrations
│ ├── fastapi.py # FastAPI middleware
│ └── langflow.py # Langflow/Flow tracing
├── schemas/ # Pydantic models
│ ├── audit.py # AuditEvent, ChangeRecord
│ ├── base.py # BaseEvent
│ ├── streaming.py # TraceEvent for streaming
│ └── enums.py # AuditAction, ResourceType, etc.
└── tracing/ # Tracing module
├── base.py # BaseTracer protocol & TracerMixin
├── factory.py # TracerFactory for creating tracers
├── agent_tracer.py # AgentTracer for AI Studio
├── workflow_tracer.py # WorkflowTracer for step timing
├── kafka_trace_producer.py # Kafka streaming producer
├── otel_utils.py # OTELManager for Logfire integration
├── logfire_integration.py # Logfire configuration
└── utils/ # Utility modules
├── token_extractors.py # Strategy pattern for token extraction
├── model_utils.py # Model name normalization
└── serialization.py # Safe serialization utilities
```
</details>
## Configuration
### Environment Variables
```bash
# Kafka Configuration
export KAFKA_BOOTSTRAP_SERVERS="kafka:9092"
export KAFKA_AUDIT_TOPIC="audit-events"
export KAFKA_SECURITY_PROTOCOL="SASL_SSL"
export KAFKA_SASL_MECHANISM="PLAIN"
export KAFKA_SASL_USERNAME="user"
export KAFKA_SASL_PASSWORD="secret"
# Service Configuration
export SERVICE_NAME="my-service"
export SERVICE_VERSION="1.0.0"
export ENVIRONMENT="production"
```
### Programmatic Configuration
```python
from autonomize_observer import init, configure, ObserverConfig, KafkaConfig
# Option 1: Direct initialization
init(
service_name="my-service",
service_version="1.0.0",
environment="production",
send_to_logfire=False,
kafka_config=KafkaConfig(bootstrap_servers="kafka:9092"),
kafka_enabled=True,
)
# Option 2: Configuration object
config = ObserverConfig(
service_name="my-service",
kafka=KafkaConfig(bootstrap_servers="kafka:9092"),
kafka_enabled=True,
)
configure(config)
```
## Testing
```bash
# Run all tests with coverage
uv run pytest tests/ -v --cov
# Run specific test modules
uv run pytest tests/test_audit_logger.py -v
uv run pytest tests/test_integrations.py -v
```
**Test Coverage: 97%+** with 574 tests covering all modules.
## Documentation
- [INSTALL.md](INSTALL.md) - Installation and setup guide
- [GUIDE.md](GUIDE.md) - Comprehensive usage guide
- [INTEGRATIONS.md](INTEGRATIONS.md) - Integration guides for Langflow, FastAPI, etc.
## Requirements
- Python 3.10+
- Dependencies:
- `logfire>=4.0.0` - OTEL tracing
- `genai-prices>=0.0.40` - LLM cost calculation
- `pydantic>=2.10.0` - Data validation
- `pyjwt>=2.10.0` - JWT token parsing
- `confluent-kafka>=2.10.0` - Kafka export (optional)
## License
Proprietary - Autonomize AI
## Support
- **Issues**: [GitHub Issues](https://github.com/autonomize-ai/autonomize-observer/issues)
- **Email**: [support@autonomize.ai](mailto:support@autonomize.ai)
---
**Autonomize Observer SDK v2.0.0** - Lightweight LLM observability and audit logging, powered by Pydantic Logfire and genai-prices.
| text/markdown | null | Jagveer Singh <jagveer@autonomize.ai> | null | null | Proprietary | audit, genai, kafka, keycloak, llm, logfire, observability, opentelemetry, tracing | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Monitoring"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"confluent-kafka>=2.10.0",
"genai-prices>=0.0.40",
"pydantic>=2.10.0",
"pyjwt>=2.10.0",
"anthropic>=0.40.0; extra == \"all\"",
"azure-eventhub>=5.11.0; extra == \"all\"",
"azure-identity>=1.15.0; extra == \"all\"",
"fastapi>=0.115.0; extra == \"all\"",
"openai>=1.50.0; extra == \"all\"",
"opentelemetry-api>=1.39.1; extra == \"all\"",
"opentelemetry-sdk>=1.39.1; extra == \"all\"",
"anthropic>=0.40.0; extra == \"anthropic\"",
"azure-eventhub>=5.11.0; extra == \"azure\"",
"azure-identity>=1.15.0; extra == \"azure\"",
"fastapi>=0.115.0; extra == \"fastapi\"",
"fastapi>=0.115.0; extra == \"fastapi-native\"",
"opentelemetry-instrumentation-fastapi>=0.48b0; extra == \"fastapi-native\"",
"logfire>=4.0.0; extra == \"logfire\"",
"opentelemetry-api>=1.39.1; extra == \"native-otel\"",
"opentelemetry-sdk>=1.39.1; extra == \"native-otel\"",
"azure-eventhub>=5.11.0; extra == \"native-otel-all\"",
"azure-identity>=1.15.0; extra == \"native-otel-all\"",
"opentelemetry-api>=1.39.1; extra == \"native-otel-all\"",
"opentelemetry-exporter-otlp-proto-grpc>=1.39.1; extra == \"native-otel-all\"",
"opentelemetry-exporter-otlp-proto-http>=1.39.1; extra == \"native-otel-all\"",
"opentelemetry-instrumentation-fastapi>=0.48b0; extra == \"native-otel-all\"",
"opentelemetry-sdk>=1.39.1; extra == \"native-otel-all\"",
"openai>=1.50.0; extra == \"openai\"",
"opentelemetry-exporter-otlp-proto-grpc>=1.39.1; extra == \"otlp\"",
"opentelemetry-exporter-otlp-proto-http>=1.39.1; extra == \"otlp\""
] | [] | [] | [] | [
"Homepage, https://github.com/autonomize-ai/autonomize-observer",
"Repository, https://github.com/autonomize-ai/autonomize-observer.git"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:24:33.838588 | autonomize_observer-2.0.10.tar.gz | 295,933 | 3b/70/7e76f31c9194e9df5ecd919b427541c807d7fef83cfe8dfc56d0995be57c/autonomize_observer-2.0.10.tar.gz | source | sdist | null | false | ce69458debbd8ac4ae6db1eb2902c88d | 12b83ea4dd61124ba50f0ef047640ddf00c6592db95796e9784980c59454e3ee | 3b707e76f31c9194e9df5ecd919b427541c807d7fef83cfe8dfc56d0995be57c | null | [
"LICENSE"
] | 249 |
2.4 | lyricsipsum | 1.1.5 | Generates Lorem Ipsum text using song lyrics | # lyricsipsum
lyricsipsum randomly selects a downloaded song's lyrics as a replacement for standard boring lorem ipsum text.
```
Usage:
lyricsipsum [options]
Options:
-d, --debug Enable debug mode
-h, --help Show this help screen
-n, --number=<num> Number of songs to download [default: 50]
-s, --save Save lyrics to file
-t, --title Print the song title along with the lyrics
--version Prints the version
```
## Installation
```bash
pip install lyricsipsum
```
### Create Configuration Directory
```bash
mkdir -p ~/.config/lyricsipsum
```
### Create configuration file
```bash
cat <<EOF > ~/.config/lyricsipsum.config.toml
[client]
verbose=true
skip_non_song=true
excluded_terms=["(Remix)", "(Live)"]
remove_section_headers=true
timeout=15
EOF
```
### Setup Genuis API Access
Following Authorization instructions on https://lyricsgenius.readthedocs.io/en/master/setup.html
## License
lyricsipsum is freeware released under the [MIT License](https://github.com/scholnicks/lyricsipsum/blob/main/LICENSE).
| text/markdown | Steve Scholnick | scholnicks@gmail.com | null | null | null | lorem, ipsum, text, generator, lyrics, utility, command-line, cli | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"License :: OSI Approved :: MIT License",
"Topic :: Utilities"
] | [] | null | null | >=3.13 | [] | [] | [] | [
"docopt-ng<0.10.0,>=0.9.0",
"lyricsgenius<4.0.0,>=3.7.2"
] | [] | [] | [] | [
"Homepage, https://pypi.org/project/lyricsipsum/",
"Repository, https://github.com/scholnicks/lyricsipsum/",
"issues, https://github.com/scholnicks/lyricsipsum/issues"
] | poetry/2.3.2 CPython/3.14.3 Darwin/25.3.0 | 2026-02-20T14:24:03.196116 | lyricsipsum-1.1.5-py3-none-any.whl | 4,594 | ea/03/1fa1eeb64f32f8ef3c10b60827f2ad27464e03b694d52eb62d093256bc33/lyricsipsum-1.1.5-py3-none-any.whl | py3 | bdist_wheel | null | false | 7ef2cb34349cd600edf0af1dd2f528b8 | 319c7c0fa1c9d7499d2676c15c27e446e20a029a51bce8fcf114e17f2e861e0b | ea031fa1eeb64f32f8ef3c10b60827f2ad27464e03b694d52eb62d093256bc33 | MIT | [
"LICENSE"
] | 204 |
2.4 | zndraw-joblib | 0.1.2 | FastAPI job queue with SQLite-backed persistence for ZnDraw | # ZnDraw Job Management Library
A self-contained FastAPI package for distributed job/task management with SQL persistence. Provides a pluggable router, ORM models, a client SDK with auto-serve, provider-based data reads, and server-side taskiq workers.
## Integration into your APP
```python
from fastapi import FastAPI
from zndraw_auth import current_active_user, current_superuser
from zndraw_auth.db import get_session_maker
from zndraw_joblib.router import router
from zndraw_joblib.exceptions import ProblemException, problem_exception_handler
from zndraw_joblib.sweeper import run_sweeper
from zndraw_joblib.settings import JobLibSettings
app = FastAPI()
# 1. Override session maker dependency at auth level
# All database access (from auth and joblib) flows through this
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
engine = create_async_engine("sqlite+aiosqlite:///./app.db")
my_session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
app.dependency_overrides[get_session_maker] = lambda: my_session_maker
# 2. Override auth dependencies (from zndraw_auth)
# app.dependency_overrides[current_active_user] = my_get_current_user
# app.dependency_overrides[current_superuser] = my_get_superuser
# 3. Register exception handler and router
app.add_exception_handler(ProblemException, problem_exception_handler)
app.include_router(router)
# 4. Start background sweeper
async def get_session():
async with my_session_maker() as session:
yield session
settings = JobLibSettings()
# asyncio.create_task(run_sweeper(get_session=get_session, settings=settings))
```
### Dependency Architecture
All database access flows through `zndraw_auth.db.get_session_maker`:
```
get_session_maker (from zndraw_auth) <- override this one dependency
+- SessionDep (regular endpoints)
+- SessionMakerDep (long-polling endpoints)
```
| Dependency | Override? | Purpose |
|------------|-----------|---------|
| `get_session_maker` | **Yes** | Single source of truth for all DB sessions (from zndraw_auth) |
| `current_active_user` | Yes (from zndraw_auth) | Authenticated user identity |
| `current_superuser` | Yes (from zndraw_auth) | Superuser access control |
| `verify_writable_room` | Optional | Room writability guard for `register_job` and `submit_task` |
| `get_tsio` | Optional | Socket.IO server for real-time events |
| `get_result_backend` | **Yes** (for providers) | Result caching backend for provider reads |
| `get_settings` | Optional | Override `JobLibSettings` defaults |
**Note**: SQLite locking is handled by the host application. For SQLite databases, wrap the session maker with a lock in your app's lifespan context.
### Room Writability Guard
The `verify_writable_room` dependency guards write endpoints (`register_job`, `submit_task`). By default it only validates the `room_id` format. Host apps can override it to add lock checks:
```python
from fastapi import Path
from zndraw_joblib import verify_writable_room, validate_room_id
async def get_writable_room(
session: SessionDep,
current_user: CurrentUserDep,
redis: RedisDep,
room_id: str = Path(),
) -> str:
validate_room_id(room_id) # format validation (@ and : checks)
room = await verify_room(session, room_id)
if room.locked and not current_user.is_superuser:
raise HTTPException(status_code=423, detail="Room is locked")
return room_id
app.dependency_overrides[verify_writable_room] = get_writable_room
```
Read endpoints and existing task/worker operations (updates, heartbeats, disconnects) are **not** affected by this guard.
## Configuration
Settings via environment variables with `ZNDRAW_JOBLIB_` prefix:
| Variable | Default | Purpose |
|----------|---------|---------|
| `ZNDRAW_JOBLIB_ALLOWED_CATEGORIES` | `["modifiers", "selections", "analysis"]` | Valid job categories |
| `ZNDRAW_JOBLIB_WORKER_TIMEOUT_SECONDS` | `60` | Stale heartbeat threshold |
| `ZNDRAW_JOBLIB_SWEEPER_INTERVAL_SECONDS` | `30` | Sweeper cycle interval |
| `ZNDRAW_JOBLIB_LONG_POLL_MAX_WAIT_SECONDS` | `60` | Max long-poll wait |
| `ZNDRAW_JOBLIB_CLAIM_MAX_ATTEMPTS` | `10` | Retries for concurrent claim contention |
| `ZNDRAW_JOBLIB_CLAIM_BASE_DELAY_SECONDS` | `0.01` | Exponential backoff base delay |
| `ZNDRAW_JOBLIB_INTERNAL_TASK_TIMEOUT_SECONDS` | `3600` | Timeout for stuck `@internal` tasks |
| `ZNDRAW_JOBLIB_ALLOWED_PROVIDER_CATEGORIES` | `None` (unrestricted) | Valid provider categories |
| `ZNDRAW_JOBLIB_PROVIDER_RESULT_TTL_SECONDS` | `300` | Cached provider result lifetime |
| `ZNDRAW_JOBLIB_PROVIDER_INFLIGHT_TTL_SECONDS` | `30` | Inflight lock lifetime |
## Job Naming Convention
Jobs use the format: `<room_id>:<category>:<name>`
- `@global:modifiers:Rotate` - global job available to all rooms
- `room_123:modifiers:Rotate` - private job for room_123 only
- `@internal:modifiers:Rotate` - server-side job executed via taskiq
**Validation rules:**
- `room_id` cannot contain `@` (reserved for `@global`/`@internal`) or `:` (delimiter)
- `category` must be in `settings.allowed_categories`
- Same job name in same room: schema must match (409 Conflict otherwise)
- Different rooms can have same job name with different schemas
## Client SDK
The `JobManager` is the main entry point for Python workers. It handles job registration, task claiming, provider dispatch, and background lifecycle management.
### Basic Usage
```python
from zndraw_joblib import JobManager, Extension, Category
# Auto-serve mode: background threads claim and execute tasks
with JobManager(api, tsio=tsio, execute=my_execute) as manager:
@manager.register
class Rotate(Extension):
category: ClassVar[Category] = Category.MODIFIER
angle: float = 0.0
def run(self, vis, **kwargs):
# modify vis based on self.angle
pass
manager.wait() # blocks until SIGINT/SIGTERM or disconnect()
# disconnect() called automatically: threads joined, worker deleted
```
### Extension Classes
Extensions are Pydantic models with a `category` ClassVar and a `run()` method:
```python
from typing import ClassVar, Any
from zndraw_joblib import Extension, Category
class Rotate(Extension):
category: ClassVar[Category] = Category.MODIFIER # or SELECTION, ANALYSIS
angle: float = 0.0
axis: str = "z"
def run(self, vis: Any, **kwargs: Any) -> None:
# Implementation here
pass
```
The JSON Schema is auto-generated from Pydantic fields and sent to the server on registration.
### Auto-Serve Mode
When an `execute` callback is provided, `JobManager` runs background threads that automatically claim and execute tasks:
```python
from zndraw_joblib import JobManager, ClaimedTask
def execute(task: ClaimedTask) -> None:
"""Called for each claimed task."""
task.extension.run(vis)
manager = JobManager(
api,
tsio=tsio,
execute=execute,
polling_interval=2.0, # how often to poll for tasks (seconds)
heartbeat_interval=30.0, # heartbeat frequency (seconds)
)
```
Background threads start on the first `register()` or `register_provider()` call:
- **Heartbeat thread** - periodic keep-alives to prevent sweeper cleanup
- **Claim loop thread** - polls for tasks, calls `execute`, marks completed/failed
The lifecycle is fully managed: `start()` is called before execute, `complete()` or `fail()` after. Exceptions in `execute` mark the task as failed with the error message.
### Manual Mode
Without `execute`, tasks must be claimed and processed manually:
```python
manager = JobManager(api, tsio=tsio)
@manager.register
class Rotate(Extension):
category: ClassVar[Category] = Category.MODIFIER
angle: float = 0.0
def run(self, vis, **kwargs): ...
# Manual claim-execute loop
for task in manager.listen(polling_interval=2.0):
manager.start(task)
try:
task.extension.run(vis)
manager.complete(task)
except Exception as e:
manager.fail(task, str(e))
```
### Task Submission
```python
task_id = manager.submit(
Rotate(angle=90.0),
room="room_123",
job_room="@global", # room where the job is registered
)
```
### Provider Registration
Providers handle server-dispatched read requests (see [Providers](#providers)):
```python
from zndraw_joblib import Provider
class FilesystemRead(Provider):
category: ClassVar[str] = "filesystem"
path: str = "/"
def read(self, handler):
return handler.ls(self.path, detail=True)
# Binary provider (e.g. msgpack, arrow, parquet)
class AtomsProvider(Provider):
category: ClassVar[str] = "atoms"
content_type: ClassVar[str] = "application/x-msgpack"
index: int = 0
def read(self, handler) -> bytes:
return handler.get_atoms_msgpack(self.index)
manager.register_provider(
FilesystemRead,
name="local",
handler=fsspec.filesystem("file"),
room="@global",
)
# Access handlers during job execution
print(manager.handlers) # {"@global:filesystem:local": <LocalFileSystem>}
```
### Lifecycle Management
```python
# Context manager (recommended)
with JobManager(api, execute=execute) as manager:
# ... register jobs/providers ...
manager.wait() # blocks until disconnect
# Manual lifecycle
manager = JobManager(api, execute=execute)
# ... register jobs/providers ...
manager.disconnect() # idempotent, safe to call multiple times
```
`disconnect()` is idempotent and handles:
1. Signaling background threads to stop
2. Joining all threads (waits for in-flight tasks to finish)
3. Emitting `LeaveJobRoom`/`LeaveProviderRoom` events
4. Calling `DELETE /workers/{id}` for server-side cleanup
Signal handlers (SIGINT/SIGTERM) call `disconnect()` automatically.
## REST Endpoints
All endpoints prefixed with `/v1/joblib`.
### Workers
```
POST /workers # Create worker (201)
GET /workers # List workers (paginated)
PATCH /workers/{worker_id} # Heartbeat
DELETE /workers/{worker_id} # Delete + cascade cleanup (204)
```
### Jobs
```
PUT /rooms/{room_id}/jobs # Register job (idempotent, 201/200)
GET /rooms/{room_id}/jobs # List jobs (room + @global, paginated)
GET /rooms/{room_id}/jobs/{job_name} # Job details
GET /rooms/{room_id}/jobs/{job_name}/tasks # Tasks for job (paginated)
```
### Tasks
```
POST /rooms/{room_id}/tasks/{job_name} # Submit task (202 Accepted)
POST /tasks/claim # Claim oldest pending (FIFO)
GET /tasks/{task_id} # Status (supports Prefer: wait=N)
PATCH /tasks/{task_id} # Update status
GET /rooms/{room_id}/tasks # List room tasks (paginated)
```
### Task Lifecycle
```
PENDING -> CLAIMED -> RUNNING -> COMPLETED
-> FAILED
-> CANCELLED
-> CANCELLED
```
Claiming uses optimistic locking with exponential backoff for concurrent safety.
Long-polling: `GET /tasks/{id}` with `Prefer: wait=N` header (max `long_poll_max_wait_seconds`). Returns immediately on terminal states.
## Providers
Providers are a generic abstraction for connected Python clients to **serve data on demand**. While jobs are user-initiated computation (workers pull tasks), providers handle **server-dispatched read requests** with result caching.
| | **Jobs** | **Providers** |
|---|---|---|
| **Purpose** | User-initiated computation | Remote resource access |
| **Dispatch** | Workers pull/claim (FIFO) | Server pushes to specific provider |
| **Results** | Side effects (modify room state) | Data returned to caller (cached) |
| **Formats** | JSON payloads | JSON or binary (msgpack, arrow, etc.) |
| **HTTP** | POST (creates task) | GET (reads resource) -> 200 or 202 |
### Content Types
Each provider declares its response format via `content_type: ClassVar[str]` (defaults to `"application/json"`). This is stored on the `ProviderRecord` at registration and used as the response `media_type` when returning cached results. Providers with `content_type != "application/json"` must return `bytes` from `read()`.
The result upload endpoint stores raw request bytes as-is -- no parsing or re-serialization. The `X-Request-Hash` header identifies the request.
### Provider Endpoints
```
PUT /rooms/{room_id}/providers # Register (201/200)
GET /rooms/{room_id}/providers # List (paginated)
GET /rooms/{room_id}/providers/{name}/info # Schema + metadata
GET /rooms/{room_id}/providers/{name}?params # Read (200 cached / 202 dispatched)
POST /providers/{provider_id}/results # Upload result (204, X-Request-Hash header)
DELETE /providers/{provider_id} # Unregister (204)
```
### Read Request Flow
```
1. Frontend: GET /rooms/room-42/providers/@global:filesystem:local?path=/data
2. Server: check cache -> HIT: return 200
-> MISS: acquire inflight, emit ProviderRequest -> return 202
3. Client: receives ProviderRequest via Socket.IO
calls provider.read(handler)
POST /providers/{id}/results (raw body + X-Request-Hash header)
4. Server: store raw bytes in ResultBackend, emit ProviderResultReady
5. Frontend: receives ProviderResultReady, re-fetches -> 200 (content_type from provider)
```
### Result Backend
Provider reads require a `ResultBackend` for caching and inflight coalescing. The host app **must** override `get_result_backend`:
```python
from zndraw_joblib.dependencies import get_result_backend
class RedisResultBackend:
def __init__(self, redis):
self._redis = redis
async def store(self, key: str, data: bytes, ttl: int) -> None:
await self._redis.set(key, data, ex=ttl)
async def get(self, key: str) -> bytes | None:
return await self._redis.get(key)
async def delete(self, key: str) -> None:
await self._redis.delete(key)
async def acquire_inflight(self, key: str, ttl: int) -> bool:
return await self._redis.set(key, b"1", nx=True, ex=ttl)
async def release_inflight(self, key: str) -> None:
await self._redis.delete(key)
app.dependency_overrides[get_result_backend] = lambda: RedisResultBackend(redis)
```
## Internal TaskIQ Workers
For server-side jobs that should execute without an external Python client, use the `@internal` room with taskiq:
```python
from zndraw_joblib import register_internal_jobs
# In your FastAPI app lifespan:
await register_internal_jobs(
app=app,
broker=redis_broker,
extensions=[MyServerSideJob],
executor=my_executor,
session_factory=my_session_maker,
)
```
This registers extensions as taskiq tasks, creates `@internal:category:name` job rows in the database, and stores the `InternalRegistry` on `app.state.internal_registry`.
For external taskiq worker processes (no FastAPI app):
```python
from zndraw_joblib import register_internal_tasks
registry = register_internal_tasks(
broker=redis_broker,
extensions=[MyServerSideJob],
executor=my_executor,
)
```
Internal tasks that exceed `internal_task_timeout_seconds` are automatically failed by the sweeper.
## Socket.IO Real-Time Events
The package emits real-time events via [zndraw-socketio](https://github.com/zincware/zndraw-socketio). The host app provides its `AsyncServerWrapper` through dependency injection:
```python
from zndraw_socketio import wrap
from zndraw_joblib.dependencies import get_tsio
tsio = wrap(socketio.AsyncServer(async_mode="asgi"))
app.dependency_overrides[get_tsio] = lambda: tsio
```
When `get_tsio` returns `None` (default), all event emissions are skipped.
### Event Models
All models are frozen Pydantic `BaseModel`s (hashable for set-based deduplication).
| Event | Payload | Room Target | Trigger |
|-------|---------|-------------|---------|
| `JobsInvalidate` | *(none)* | `room:{room_id}` | Job registered/deleted, worker connected/disconnected |
| `TaskAvailable` | `job_name`, `room_id`, `task_id` | `jobs:{full_name}` | Task submitted (non-`@internal` only) |
| `TaskStatusEvent` | `id`, `name`, `room_id`, `status`, timestamps, `worker_id`, `error` | `room:{room_id}` | Any task status transition |
| `ProvidersInvalidate` | *(none)* | `room:{room_id}` | Provider registered/deleted, worker disconnected |
| `ProviderRequest` | `request_id`, `provider_name`, `params` | `providers:{full_name}` | Server dispatches read to provider |
| `ProviderResultReady` | `provider_name`, `request_hash` | `room:{room_id}` | Provider result cached |
| `JoinJobRoom` | `job_name`, `worker_id` | *(client -> server)* | Worker joins notification room |
| `LeaveJobRoom` | `job_name`, `worker_id` | *(client -> server)* | Worker leaves notification room |
| `JoinProviderRoom` | `provider_name`, `worker_id` | *(client -> server)* | Client joins provider dispatch room |
| `LeaveProviderRoom` | `provider_name`, `worker_id` | *(client -> server)* | Client leaves provider dispatch room |
### Emission Deduplication
Internally, emissions are `Emission(NamedTuple)` pairs of `(event, room)`. Functions that modify state return `set[Emission]`, and callers emit **after commit**. Frozen models ensure duplicate events are deduplicated automatically.
### Worker Notification Pattern
```python
# 1. Register job via REST
client.put("/v1/joblib/rooms/@global/jobs", json={...})
# 2. Join the job's socketio room
await sio.emit(JoinJobRoom(job_name="@global:modifiers:Rotate", worker_id="..."))
# 3. Receive TaskAvailable when tasks are submitted
@sio.on(TaskAvailable)
async def on_task_available(sid: str, data: TaskAvailable):
await worker.claim_and_run(data.job_name)
```
### Server-Side Disconnect Cleanup
When a worker's Socket.IO connection drops, the host app can immediately clean up:
```python
from zndraw_joblib import cleanup_worker, emit
@tsio.on("disconnect")
async def on_disconnect(sid: str, reason: str):
session = await tsio.get_session(sid)
worker_id = session.get("worker_id")
if worker_id:
async with get_session() as db:
worker = await db.get(Worker, UUID(worker_id))
if worker:
emissions = await cleanup_worker(db, worker)
await db.commit()
await emit(tsio, emissions)
```
| Disconnect Scenario | Handler |
|---------------------|---------|
| Network drop / process kill | Server-side SIO disconnect (immediate) |
| Graceful shutdown (`with manager:`) | Client `disconnect()` emits leave events + `DELETE /workers` |
| REST-only workers (no SIO) | Background sweeper heartbeat timeout |
## Background Sweeper
Host app starts explicitly:
```python
from zndraw_joblib import run_sweeper
asyncio.create_task(
run_sweeper(get_session=my_session_factory, settings=settings, tsio=tsio)
)
```
The sweeper runs periodically (`sweeper_interval_seconds`) and:
1. Finds workers with stale `last_heartbeat` (beyond `worker_timeout_seconds`)
2. Marks their `running`/`claimed` tasks as `FAILED`
3. Removes orphan jobs (no workers, no pending tasks, not `@internal`)
4. Cleans up `@internal` tasks stuck beyond `internal_task_timeout_seconds`
5. Emits `TaskStatusEvent` and `JobsInvalidate` events after each cleanup cycle
## Error Handling (RFC 9457)
All errors use [RFC 9457 Problem Details](https://www.rfc-editor.org/rfc/rfc9457) format:
| Exception | Status | Description |
|-----------|--------|-------------|
| `JobNotFound` | 404 | Job does not exist |
| `SchemaConflict` | 409 | Job schema differs from existing registration |
| `InvalidCategory` | 400 | Category not in allowed list |
| `WorkerNotFound` | 404 | Worker does not exist |
| `TaskNotFound` | 404 | Task does not exist |
| `InvalidTaskTransition` | 409 | Invalid status transition |
| `InvalidRoomId` | 400 | Room ID contains `@` or `:` |
| `Forbidden` | 403 | Admin privileges required |
| `InternalJobNotConfigured` | 503 | Internal job has no executor |
| `ProviderNotFound` | 404 | Provider does not exist |
## ORM Models
Models use SQLAlchemy 2.0 ORM inheriting from `zndraw_auth.Base`:
- **Job** - `(room_id, category, name)` unique, soft-deleted via `deleted` flag
- **Worker** - Tracks `last_heartbeat`, linked to user via `user_id`
- **Task** - Status state machine, linked to job and claiming worker
- **WorkerJobLink** - M:N bridge between Worker and Job
- **ProviderRecord** - `(room_id, category, name)` unique, linked to worker, stores `content_type` for response media type
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"fastapi>=0.128.0",
"httpx>=0.28.1",
"pydantic-settings>=2.12.0",
"pydantic>=2.12.5",
"sqlmodel>=0.0.31",
"taskiq-redis>=1.2.2",
"taskiq>=0.12.1",
"zndraw-auth",
"zndraw-socketio"
] | [] | [] | [] | [] | uv/0.10.1 {"installer":{"name":"uv","version":"0.10.1","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-20T14:23:57.582781 | zndraw_joblib-0.1.2.tar.gz | 243,007 | 95/35/f08bbe643f9cf54f3ba703873484c73fb8b231d14244093070ff6e59d438/zndraw_joblib-0.1.2.tar.gz | source | sdist | null | false | b200becca026b9889c1b1a7663b974e1 | c24a5525d32d9d2f48e476c858a747c8fa4e077d4e4f3f987457bae7b7ff81b4 | 9535f08bbe643f9cf54f3ba703873484c73fb8b231d14244093070ff6e59d438 | null | [
"LICENSE"
] | 210 |
2.3 | yosoi | 0.0.1a9 | AI-Powered Selector Discovery - Discover once, scrape forever | [](https://doi.org/10.5281/zenodo.18713573)
[](https://opensource.org/licenses/Apache-2.0)
[](https://github.com/astral-sh/uv)
[](https://github.com/CascadingLabs/Yosoi/actions)
[](https://pypi.python.org/pypi/yosoi)
[](https://pypi.python.org/pypi/yosoi)
<!-- [](https://pypi.python.org/pypi/yosoi) -->
# Yosoi - AI-Powered CSS Selector Discover
> **Discover CSS selectors once with AI, scrape forever with BeautifulSoup**
Give Yosoi a URL, and it uses AI to automatically discover the best CSS selectors for extracting headlines, authors, dates, body text, and related content. Discovery takes 3 seconds and costs $0.001 per domain — then scrape thousands of articles for free with BeautifulSoup.
**Key Benefits:**
- **Fast**: 3 seconds to discover selectors per domain
- **Cheap**: $0.001 per domain (one-time cost)
- **Accurate**: Validates selectors before saving
- **Reusable**: Discover once, use forever
- **Production-Ready**: Type-safe, linted, tested
## Quick Start
### Installation
```bash
# Clone the repository
git clone <your-repo>
cd yosoi
# Install dependencies (using uv)
uv sync
# For development tools
uv sync --group dev
```
### Configuration
Create a `.env` file (see `env.example`):
```bash
# Choose one or both providers
GROQ_KEY=your_groq_api_key_here # For Llama 3.3 (faster, recommended)
GEMINI_KEY=your_gemini_api_key_here # For Gemini 2.0 Flash
# Optional: Observability
LOGFIRE_TOKEN=your_logfire_token_here # For Logfire tracing
```
**Get API Keys:**
- Groq (Free): https://console.groq.com/keys
- Gemini: https://aistudio.google.com/app/apikey
- Logfire (Optional): https://logfire.pydantic.dev
### Basic Usage
```bash
# Process a single URL
uv run yosoi --url https://example.com/article
# Process multiple URLs from a file
uv run yosoi --file urls.txt
# Force re-discovery
uv run yosoi --url https://example.com --force
# Show summary of all saved selectors
uv run yosoi --summary
# Enable debug mode (saves extracted HTML)
uv run yosoi --url https://example.com --debug
```
### URLs File Format
Create `urls.txt` with one URL per line:
```text
https://example.com/article1
https://example.com/article2
# Comments are allowed
https://example.com/article3
```
Or use JSON format (`urls.json`):
```json
[
{"url": "https://example.com/article1"},
{"url": "https://example.com/article2"}
]
```
## Project Structure
```
.
├── .yosoi/ # .yosoi helper directory (hidden)
│ └── selectors/ # Discovered selectors (hidden)
├── main.py # CLI entry point & orchestrator
├── selector_discovery.py # AI-powered selector discovery
├── selector_validator.py # Selector validation & testing
├── selector_storage.py # JSON storage operations
├── services.py # Shared services (Logfire config)
├── models.py # Pydantic models
├── pyproject.toml # Project config & dependencies
├── .env # API keys (create this)
├── CHEAT_SHEET.md # Dev tools quick reference
└── selectors/ # Output directory
└── selectors_*.json # Discovered selectors per domain
```
## How It Works
### Phase 1: Smart HTML Extraction
```
Full HTML (2MB)
↓
Remove noise (scripts, styles, nav, footer)
↓
Find main content (<article>, <main>, .content)
↓
Extract ~30k chars of relevant HTML
↓
Send to AI
```
### Phase 2: AI Analysis
```
AI reads actual HTML structure
↓
Finds real class names & IDs
↓
Returns 3 selectors per field:
- Primary (most specific)
- Fallback (reliable backup)
- Tertiary (generic)
↓
Smart fallback if AI fails
```
### Phase 3: Validation
```
Test each selector on the actual page
↓
Find first working selector per field
↓
Mark which priority worked (primary/fallback/tertiary)
↓
Save validated selectors to JSON
```
## Output Format
Selectors are saved as JSON files in the `.yosoi/selectors/` directory:
```json
{
"headline": {
"primary": "h1.article-title",
"fallback": "h1",
"tertiary": "h2"
},
"author": {
"primary": "a[href*='/author/']",
"fallback": ".byline",
"tertiary": "NA"
},
"date": {
"primary": "time.published-date",
"fallback": "time",
"tertiary": ".date"
},
"body_text": {
"primary": "article.content p",
"fallback": "article p",
"tertiary": "p"
},
"related_content": {
"primary": "aside.related a",
"fallback": ".sidebar a",
"tertiary": "NA"
}
}
```
## Using Discovered Selectors
Once selectors are discovered, use them with standard BeautifulSoup:
```python
from selector_storage import SelectorStorage
from bs4 import BeautifulSoup
import requests
# Load discovered selectors
storage = SelectorStorage()
selectors = storage.load_selectors('example.com')
# Scrape using the selectors (fast & free!)
url = 'https://example.com/another-article'
html = requests.get(url).text
soup = BeautifulSoup(html, 'html.parser')
# Extract data using validated selectors
headline_selector = selectors['headline']['primary']
headline = soup.select_one(headline_selector)
if headline:
print(f"Headline: {headline.get_text(strip=True)}")
# Extract body text
body_selector = selectors['body_text']['primary']
paragraphs = soup.select(body_selector)
body_text = '\n\n'.join(p.get_text(strip=True) for p in paragraphs)
print(f"\nBody:\n{body_text}")
```
### Using as a Library
```python
from main import SelectorDiscoveryPipeline
import os
# Initialize with your preferred provider
pipeline = SelectorDiscoveryPipeline(
ai_api_key=os.getenv('GROQ_KEY'),
model_name='llama-3.3-70b-versatile',
provider='groq'
)
# Process a URL
success = pipeline.process_url('https://example.com/article')
# Process multiple URLs
urls = ['https://example.com/article1', 'https://example.com/article2']
pipeline.process_urls(urls, force=False)
# Show summary
pipeline.show_summary()
```
## Supported AI Models
### Groq (Recommended)
- **Model**: `llama-3.3-70b-versatile`
- **Cost**: Free tier available
- **Setup**: `GROQ_KEY` in `.env`
### Google Gemini
- **Model**: `gemini-2.0-flash-exp`
- **Cost**: Free tier available
- **Setup**: `GEMINI_KEY` in `.env`
The system automatically uses Groq if `GROQ_KEY` is set, otherwise falls back to Gemini.
## Observability with Logfire
Yosoi integrates with [Logfire](https://logfire.pydantic.dev) for comprehensive observability:
**What's Tracked:**
- Request/response traces for each URL
- AI model calls and responses
- Selector validation results
- Performance metrics
- Error tracking
**Enable Logfire:**
1. Sign up at https://logfire.pydantic.dev
2. Get your token
3. Add `LOGFIRE_TOKEN=your_token` to `.env`
4. Run your discovery process
5. View traces in Logfire dashboard
## Features
**AI-Powered** - Uses Groq/Gemini to read HTML and find selectors
**Cheap** - $0.001 per domain
**Validated** - Tests each selector before saving
**Organized** - Clean JSON output per domain
**Fallback System** - Uses heuristics when AI fails
**Rich CLI** - Nice terminal output with progress indicators
**Type-Safe** - Full type hints with mypy checking
**Observable** - Integrated with Logfire for tracing
**Production-Ready** - Linted, formatted, and tested
## Troubleshooting
### AI Returns All "NA"
**Cause**: Site has poor semantic HTML or heavy JavaScript rendering
**Solution**:
- Check if site requires JavaScript (use debug mode: `--debug`)
- Review extracted HTML in `debug_html/` directory
- Consider using Selenium for JavaScript-heavy sites
- Fallback heuristics will be used automatically
### Selectors Don't Work
**Cause**: Site structure changed or uses dynamic content
**Solution**:
- Re-run with `--force` to re-discover selectors
- Check if site requires authentication
- Verify selectors with `--debug` mode
### API Key Errors
**Problem**: `GROQ_KEY` or `GEMINI_KEY` not found
**Solution**:
- Ensure `.env` file exists in project root
- Verify key is correctly formatted (no quotes needed)
- Check key has not expired at provider's dashboard
### HTTP Errors (403, 429, 500)
- **403 Forbidden**: Site blocks scrapers - may need different User-Agent
- **429 Too Many Requests**: Rate limited - add delays between requests
- **5xx Server Error**: Server issue - Yosoi will skip retries automatically
### Import Errors
**Problem**: `ModuleNotFoundError` for pydantic_ai, logfire, etc.
**Solution**:
```bash
# Reinstall dependencies
uv sync
# If still failing, try clean install
rm -rf .venv
uv sync
```
## Best Practices
### For Reliable Scraping
1. **Test on multiple pages**: Validate selectors work across different articles
2. **Use fallback selectors**: Always have primary/fallback/tertiary
3. **Monitor changes**: Re-discover periodically (sites change)
4. **Handle missing data**: Not all fields exist on all pages
### For Better AI Results
1. **Use debug mode first**: Check what HTML is being sent to AI
2. **Prefer semantic HTML**: Sites with `<article>`, `<time>`, etc. work best
3. **Avoid paywalled sites**: Content behind login walls won't work
4. **Check rate limits**: Respect site's `robots.txt` and rate limits
### For Production Use
1. **Cache selectors**: Store and reuse for same domain
2. **Add error handling**: Sites can change or go down
3. **Use Logfire**: Monitor success rates and failures
4. **Set timeouts**: Don't let requests hang indefinitely
## Limitations / Future Developments
- **JavaScript-rendered content**: Not visible in raw HTML (maybe a future development)
- **Paywalled sites**: Cannot access content behind logins
- **Dynamic selectors**: Sites that change class names frequently
- **Rate limits**: Some sites may block or rate-limit requests
## Citation
If you use **yosoi** in your research or project, please cite it using the metadata provided in the `CITATION.cff` file.
### BibTeX
If you are using LaTeX, you can use the following entry:
```bibtex
@software{Berg_yosoi_2026,
author = {Berg, Andrew and Miles, Houston and Mefford, Braeden and Wang, Mia},
license = {Apache-2.0},
month = feb,
title = {{yosoi}},
url = {https://github.com/CascadingLabs/Yosoi},
version = {0.0.1-alpha6},
year = {2026}
}
```
| text/markdown | null | null | null | null | Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
You must give any other recipients of the Work or Derivative Works a copy of this License; and
You must cause any modified files to carry prominent notices stating that You changed the files; and
You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"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 :: WWW/HTTP :: Dynamic Content",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"beautifulsoup4>=4.12",
"brotli>=1.1",
"logfire>=4.16",
"lxml>=6.0.2",
"pydantic>=2",
"pydantic-ai>=0.0.16",
"python-dotenv>=1.2.1",
"requests>=2.31",
"rich>=14.2",
"tenacity>=9.1.4"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:23:51.079613 | yosoi-0.0.1a9.tar.gz | 45,994 | 1e/44/a01ae8b6474be9b4eccefcba590fe7e5527b4e5eaafa87844e1256ff614c/yosoi-0.0.1a9.tar.gz | source | sdist | null | false | 2e32b1e67e9d348d74ff9e1d443715cb | a7a1433271b1e63ce7bb7d4eed3b9db6b4eb1cc706613834091dad38851ff32a | 1e44a01ae8b6474be9b4eccefcba590fe7e5527b4e5eaafa87844e1256ff614c | null | [] | 199 |
2.3 | zndraw-auth | 0.2.2 | Shared authentication for ZnDraw using fastapi-users | # zndraw-auth
Shared authentication package for the ZnDraw ecosystem using [fastapi-users](https://fastapi-users.github.io/fastapi-users/).
## Installation
```bash
pip install zndraw-auth
# or with uv
uv add zndraw-auth
```
## Quick Start
```python
from contextlib import asynccontextmanager
from fastapi import Depends, FastAPI
from sqlalchemy.ext.asyncio import async_sessionmaker
from zndraw_auth import (
AuthSettings,
User,
UserCreate,
UserRead,
UserUpdate,
auth_backend,
create_engine_for_url,
current_active_user,
ensure_default_admin,
fastapi_users,
)
from zndraw_auth.db import Base
settings = AuthSettings()
engine = create_engine_for_url("sqlite+aiosqlite://")
@asynccontextmanager
async def lifespan(app: FastAPI):
# Store state for DI
app.state.engine = engine
app.state.session_maker = async_sessionmaker(engine, expire_on_commit=False)
app.state.auth_settings = settings
# Create all tables
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
# Create default admin user
async with app.state.session_maker() as session:
await ensure_default_admin(session, settings)
yield
await engine.dispose()
app = FastAPI(lifespan=lifespan)
# Include auth routers
app.include_router(
fastapi_users.get_auth_router(auth_backend),
prefix="/auth/jwt",
tags=["auth"],
)
app.include_router(
fastapi_users.get_register_router(UserRead, UserCreate),
prefix="/auth",
tags=["auth"],
)
app.include_router(
fastapi_users.get_users_router(UserRead, UserUpdate),
prefix="/users",
tags=["users"],
)
@app.get("/protected")
async def protected_route(user: User = Depends(current_active_user)):
return {"message": f"Hello {user.email}!"}
```
## Available Routers
zndraw-auth provides access to three fastapi-users routers that you can include in your app:
### Authentication Router
```python
app.include_router(
fastapi_users.get_auth_router(auth_backend),
prefix="/auth/jwt",
tags=["auth"],
)
```
**Provides:**
- `POST /auth/jwt/login` - Login with email/password, returns JWT token
- `POST /auth/jwt/logout` - Logout (revokes token)
### Registration Router
```python
app.include_router(
fastapi_users.get_register_router(UserRead, UserCreate),
prefix="/auth",
tags=["auth"],
)
```
**Provides:**
- `POST /auth/register` - Create new user account
### Users Router (Profile & User Management)
```python
app.include_router(
fastapi_users.get_users_router(UserRead, UserUpdate),
prefix="/users",
tags=["users"],
)
```
**Provides:**
- `GET /users/me` - Get current user profile (email, is_superuser, etc.)
- `PATCH /users/me` - Update own profile (email, password)
- `GET /users/{user_id}` - Get any user (superuser only)
- `PATCH /users/{user_id}` - Update any user (superuser only)
- `DELETE /users/{user_id}` - Delete user (superuser only)
**When to include:**
- ✅ Include if clients need to view/edit user profiles
- ✅ Include if superusers need to manage users via API
- ⚠️ Skip if you implement custom user management endpoints
**Example client usage:**
```bash
# Get current user profile (requires authentication)
curl -H "Authorization: Bearer $TOKEN" http://localhost:8000/users/me
# Response:
# {
# "id": "4fd3477b-eccf-4ee3-8f7d-68ad72261476",
# "email": "user@example.com",
# "is_active": true,
# "is_superuser": false,
# "is_verified": false
# }
```
## Extending with Custom Models (e.g., zndraw-joblib)
Other packages can import `Base` and `SessionDep` to define models that share the same database and have foreign key relationships to `User`.
### Example: Adding a Job model in zndraw-joblib
```python
# zndraw_joblib/models.py
import uuid
from typing import TYPE_CHECKING
from sqlalchemy import ForeignKey, String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from zndraw_auth import Base
if TYPE_CHECKING:
from zndraw_auth import User
class Job(Base):
"""A compute job owned by a user."""
__tablename__ = "job"
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
name: Mapped[str] = mapped_column(String(255))
status: Mapped[str] = mapped_column(String(50), default="pending")
# Foreign key to User from zndraw-auth (cascade delete when user is deleted)
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("user.id", ondelete="cascade"))
# Relationship (optional, for ORM navigation)
user: Mapped["User"] = relationship("User", lazy="selectin")
```
### Example: Using the shared session in endpoints
```python
# zndraw_joblib/routes.py
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import select
from zndraw_auth import SessionDep, User, current_active_user
from .models import Job
router = APIRouter(prefix="/jobs", tags=["jobs"])
@router.post("/")
async def create_job(
name: str,
user: Annotated[User, Depends(current_active_user)],
session: SessionDep,
):
"""Create a new job for the current user."""
job = Job(name=name, user_id=user.id)
session.add(job)
await session.commit()
await session.refresh(job)
return {"id": str(job.id), "name": job.name, "status": job.status}
@router.get("/")
async def list_jobs(
user: Annotated[User, Depends(current_active_user)],
session: SessionDep,
):
"""List all jobs for the current user."""
result = await session.execute(
select(Job).where(Job.user_id == user.id)
)
jobs = result.scalars().all()
return [{"id": str(j.id), "name": j.name, "status": j.status} for j in jobs]
@router.get("/{job_id}")
async def get_job(
job_id: UUID,
user: Annotated[User, Depends(current_active_user)],
session: SessionDep,
):
"""Get a specific job (must belong to current user)."""
result = await session.execute(
select(Job).where(Job.id == job_id, Job.user_id == user.id)
)
job = result.scalar_one_or_none()
if not job:
raise HTTPException(status_code=404, detail="Job not found")
return {"id": str(job.id), "name": job.name, "status": job.status}
```
### Example: App setup with multiple routers
```python
# main.py (in zndraw-fastapi or combined app)
from contextlib import asynccontextmanager
from fastapi import FastAPI
from sqlalchemy.ext.asyncio import async_sessionmaker
from zndraw_auth import (
AuthSettings,
UserCreate,
UserRead,
UserUpdate,
auth_backend,
create_engine_for_url,
ensure_default_admin,
fastapi_users,
)
from zndraw_auth.db import Base
from zndraw_joblib.routes import router as jobs_router
settings = AuthSettings()
engine = create_engine_for_url("sqlite+aiosqlite:///./zndraw.db")
@asynccontextmanager
async def lifespan(app: FastAPI):
# Store state for DI
app.state.engine = engine
app.state.session_maker = async_sessionmaker(engine, expire_on_commit=False)
app.state.auth_settings = settings
# Create all tables (User from zndraw-auth AND Job from zndraw-joblib)
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
# Create default admin user
async with app.state.session_maker() as session:
await ensure_default_admin(session, settings)
yield
await engine.dispose()
app = FastAPI(lifespan=lifespan)
# Auth routes from zndraw-auth
app.include_router(
fastapi_users.get_auth_router(auth_backend),
prefix="/auth/jwt",
tags=["auth"],
)
app.include_router(
fastapi_users.get_register_router(UserRead, UserCreate),
prefix="/auth",
tags=["auth"],
)
app.include_router(
fastapi_users.get_users_router(UserRead, UserUpdate),
prefix="/users",
tags=["users"],
)
# Job routes from zndraw-joblib
app.include_router(jobs_router)
```
## Configuration
Settings are loaded from environment variables with the `ZNDRAW_AUTH_` prefix:
| Variable | Default | Description |
|----------|---------|-------------|
| `ZNDRAW_AUTH_SECRET_KEY` | `CHANGE-ME-IN-PRODUCTION` | JWT signing secret |
| `ZNDRAW_AUTH_TOKEN_LIFETIME_SECONDS` | `3600` | JWT token lifetime |
| `ZNDRAW_AUTH_RESET_PASSWORD_TOKEN_SECRET` | `CHANGE-ME-RESET` | Password reset token secret |
| `ZNDRAW_AUTH_VERIFICATION_TOKEN_SECRET` | `CHANGE-ME-VERIFY` | Email verification token secret |
| `ZNDRAW_AUTH_DEFAULT_ADMIN_EMAIL` | `None` | Email for the default admin user |
| `ZNDRAW_AUTH_DEFAULT_ADMIN_PASSWORD` | `None` | Password for the default admin user |
**Note:** The database URL is not configured here — the host application creates the engine and stores it in `app.state`. Use `create_engine_for_url()` for automatic pool selection.
### Dev Mode vs Production Mode
The system has two operating modes based on admin configuration:
**Dev Mode** (default - no admin configured):
- All newly registered users are automatically granted superuser privileges
- Useful for development and testing
**Production Mode** (admin configured):
- Set `ZNDRAW_AUTH_DEFAULT_ADMIN_EMAIL` and `ZNDRAW_AUTH_DEFAULT_ADMIN_PASSWORD`
- The configured admin user is created/promoted on startup
- New users are created as regular users (not superusers)
```bash
# Production mode example
export ZNDRAW_AUTH_DEFAULT_ADMIN_EMAIL=admin@example.com
export ZNDRAW_AUTH_DEFAULT_ADMIN_PASSWORD=secure-password
```
## Exports
```python
from zndraw_auth import (
# SQLAlchemy Base (for extending with your own models)
Base,
# User model
User,
# Database dependencies (read from app.state)
get_engine, # Retrieves engine from app.state
get_session_maker, # Retrieves async_sessionmaker from app.state
get_session, # Yields request-scoped session
SessionDep, # Type alias: Annotated[AsyncSession, Depends(get_session)]
get_user_db, # FastAPI-Users database adapter
# Database utilities
create_engine_for_url, # Factory for engines with automatic pool selection
ensure_default_admin, # Create/promote default admin user
# Pydantic schemas
UserCreate, # For registration (get_register_router)
UserRead, # For responses (all routers)
UserUpdate, # For profile updates (get_users_router)
TokenResponse, # JWT token response schema
# Settings
AuthSettings, # Pydantic settings model
AuthSettingsDep, # Type alias: Annotated[AuthSettings, Depends(get_auth_settings)]
get_auth_settings, # Retrieves settings from app.state
# User manager (for custom lifecycle hooks)
UserManager,
get_user_manager,
# FastAPIUsers instance (for including routers)
fastapi_users,
auth_backend,
# Dependencies for Depends()
current_active_user, # Requires authenticated active user
current_superuser, # Requires superuser
current_optional_user, # User | None (optional auth)
)
```
## License
MIT
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"fastapi>=0.128.0",
"fastapi-users[sqlalchemy]>=14.0.0",
"pydantic-settings>=2.0.0",
"sqlalchemy[asyncio]>=2.0.0",
"sqlmodel>=0.0.22",
"aiosqlite>=0.19.0",
"pytest>=8.0.0; extra == \"dev\"",
"pytest-asyncio>=0.23.0; extra == \"dev\"",
"httpx>=0.27.0; extra == \"dev\"",
"ruff>=0.8.0; extra == \"dev\"",
"mypy>=1.0.0; extra == \"dev\""
] | [] | [] | [] | [] | uv/0.10.1 {"installer":{"name":"uv","version":"0.10.1","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-20T14:23:11.504883 | zndraw_auth-0.2.2-py3-none-any.whl | 11,361 | cc/4f/a4ccc310a968a3c99ca4448f0d126f85b2037a9da88642db0962f7a9e357/zndraw_auth-0.2.2-py3-none-any.whl | py3 | bdist_wheel | null | false | ec94ebc6fd2635f0a113e8221f12a479 | e3ccb2a526186fa794b25100c30d31c303c23a03709e4fa58db30310002d6040 | cc4fa4ccc310a968a3c99ca4448f0d126f85b2037a9da88642db0962f7a9e357 | null | [] | 214 |
2.4 | rhiza-tools | 0.3.5b2 | Extra utilities and tools for the Rhiza ecosystem | <div align="center">
# <img src="https://raw.githubusercontent.com/Jebel-Quant/rhiza/main/.rhiza/assets/rhiza-logo.svg" alt="Rhiza Logo" width="30" style="vertical-align: middle;"> rhiza-tools
[](https://pypi.org/project/rhiza-tools/)
[](https://opensource.org/licenses/MIT)
[](https://jebel-quant.github.io/rhiza-tools/tests/html-coverage/index.html)
[](https://pepy.tech/project/rhiza-tools)
[](https://www.codefactor.io/repository/github/jebel-quant/rhiza-tools)
Extra utilities and tools serving the mothership [rhiza](https://github.com/Jebel-Quant/rhiza).
**📖 New to Rhiza? Check out the [Getting Started Guide](https://github.com/Jebel-Quant/rhiza-cli/blob/ad816ff3e91a8d6f07fcba979bc64576de3d0116/GETTING_STARTED.md) for a beginner-friendly introduction!**
</div>
This package provides additional commands for the Rhiza ecosystem, such as version bumping, release management, and documentation helpers. It can be used as a plugin for `rhiza-cli` or as a standalone tool.
## Installation
### As a Rhiza Plugin (Recommended)
You can install `rhiza-tools` alongside `rhiza-cli` using `uvx` or `pip`. This automatically registers the tools as subcommands under `rhiza tools`.
#### Using uvx (run without installation)
```bash
uvx "rhiza[tools]" tools --help
```
#### Using pip
```bash
pip install "rhiza[tools]"
```
### Standalone Usage
You can also use `rhiza-tools` independently if you don't need the full `rhiza` CLI.
#### Using uvx
```bash
uvx rhiza-tools --help
```
#### Using pip
```bash
pip install rhiza-tools
```
## Commands
### `bump`
Bump the version of the project in `pyproject.toml` using semantic versioning.
Supports interactive selection, explicit version targets, and prerelease types.
**Usage:**
```bash
# Interactive (prompts for bump type)
rhiza-tools bump
# Explicit bump type
rhiza-tools bump patch
rhiza-tools bump minor
rhiza-tools bump major
# Explicit version
rhiza-tools bump 2.0.0
# Prerelease types
rhiza-tools bump alpha
rhiza-tools bump beta
rhiza-tools bump rc
```
**Arguments:**
* `VERSION` - The version to bump to. Can be an explicit version (e.g., `1.0.1`),
a bump type (`patch`, `minor`, `major`), a prerelease type (`alpha`, `beta`, `rc`, `dev`),
or omitted for interactive selection.
**Options:**
* `--dry-run` - Show what would change without actually modifying files.
* `--commit` - Automatically commit the version change to git.
* `--push` - Push changes to remote after commit (implies `--commit`).
* `--branch BRANCH` - Branch to perform the bump on (switches back after).
* `--allow-dirty` - Allow bumping even with uncommitted changes.
* `--verbose`, `-v` - Show detailed output from bump-my-version.
### `release`
Push a release tag to remote to trigger the automated release workflow.
Optionally bumps the version before releasing.
**Usage:**
```bash
# Interactive (prompts for bump and push)
rhiza-tools release
# Dry-run preview
rhiza-tools release --dry-run
# Bump and release in one step
rhiza-tools release --bump MINOR --push
# Interactive bump selection with dry-run preview
rhiza-tools release --with-bump --push --dry-run
# Non-interactive (for CI/CD)
rhiza-tools release --bump PATCH --push --non-interactive
```
**Options:**
* `--bump TYPE` - Bump type (`MAJOR`, `MINOR`, `PATCH`) to apply before release.
* `--with-bump` - Interactively select bump type before release (works with `--dry-run`).
* `--push` - Push changes to remote (default: prompt in interactive mode).
* `--dry-run` - Show what would happen without making any changes.
* `--non-interactive`, `-y` - Skip all confirmation prompts (for CI/CD).
### `update-readme`
Update `README.md` with the current output from `make help`.
**Usage:**
```bash
# As plugin
rhiza tools update-readme
# Standalone
rhiza-tools update-readme
```
**Options:**
* `--dry-run` - Print what would happen without actually changing files.
### `generate-coverage-badge`
Generate a coverage badge JSON file from a pytest-cov coverage report.
The badge color adjusts automatically based on the coverage percentage.
**Usage:**
```bash
# Default paths
rhiza-tools generate-coverage-badge
# Custom paths
rhiza-tools generate-coverage-badge \
--coverage-json tests/coverage.json \
--output assets/badge.json
```
**Options:**
* `--coverage-json PATH` - Path to the coverage.json file (default: `_tests/coverage.json`).
* `--output PATH` - Path to output badge JSON (default: `_book/tests/coverage-badge.json`).
### `version-matrix`
Emit supported Python versions from `pyproject.toml` as a JSON array.
Primarily used in GitHub Actions to compute the CI test matrix.
**Usage:**
```bash
# Default candidates
rhiza-tools version-matrix
# Custom pyproject path
rhiza-tools version-matrix --pyproject /path/to/pyproject.toml
# Custom candidate versions
rhiza-tools version-matrix --candidates "3.10,3.11,3.12"
```
**Options:**
* `--pyproject PATH` - Path to pyproject.toml (default: `pyproject.toml`).
* `--candidates TEXT` - Comma-separated list of candidate Python versions (default: `3.11,3.12,3.13,3.14`).
### `analyze-benchmarks`
Analyze pytest-benchmark results and generate an interactive HTML visualization.
Prints a table of benchmark names, mean runtimes, and operations per second.
**Usage:**
```bash
# Default paths
rhiza-tools analyze-benchmarks
# Custom paths
rhiza-tools analyze-benchmarks \
--benchmarks-json tests/benchmarks.json \
--output-html reports/benchmarks.html
```
**Options:**
* `--benchmarks-json PATH` - Path to benchmarks.json file (default: `_benchmarks/benchmarks.json`).
* `--output-html PATH` - Path to save HTML visualization (default: `_benchmarks/benchmarks.html`).
## Development
### Prerequisites
* Python 3.11 or higher
* `uv` package manager (recommended) or `pip`
* Git
### Setup Development Environment
```bash
# Clone the repository
git clone https://github.com/Jebel-Quant/rhiza-tools.git
cd rhiza-tools
# Install dependencies
make install
# Run tests
make test
```
## License
This project is licensed under the MIT License.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"bump-my-version==1.2.7",
"loguru>=0.7.3",
"pandas<3.1,>=3",
"plotly<7.0,>=6.5.0",
"questionary>=2.1.1",
"semver>=3.0.4",
"tomlkit>=0.13.3",
"typer>=0.9.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:23:10.935480 | rhiza_tools-0.3.5b2.tar.gz | 246,820 | b9/93/557562573e25e52617ab693382819e069fed7a9a0c0313820807ee804057/rhiza_tools-0.3.5b2.tar.gz | source | sdist | null | false | e15573705a8ff5298e71f4ebc10c2d5f | 4fa7d7f3fbd9c45f1b6cb3fb3caf7cbea352063c95f9714fc9822220bb62ff02 | b993557562573e25e52617ab693382819e069fed7a9a0c0313820807ee804057 | null | [
"LICENSE"
] | 174 |
2.4 | datastorage | 0.7 | Dict-like object that can be saved in hdf5 or numpy format | datastorage
-----------
To use simply do::
>>> from datastorage import DataStorage
>>> data = DataStorage( a=(1,2,3),b="add",filename='store.npz' )
>>> # data.a will be a dictionary
>>> data = DataStorage( myinfo = dict( name= 'marco', surname= 'cammarata'),\
>>> data = np.arange(100) )
>>> # reads from file if it exists
>>> data = DataStorage( 'mysaveddata.npz' ) ;
>>> create empty storage (with default filename)
>>> data = DataStorage()
>>> data.mynewdata = np.ones(10)
| null | marco cammarata | marcocammarata@gmail.com | null | null | MIT | null | [] | [] | https://github.com/marcocamma/datastorage | null | null | [] | [] | [] | [
"numpy",
"h5py"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:23:01.788214 | datastorage-0.7.tar.gz | 13,567 | af/41/a36ab236e25a30758b5ca2b0269f882588dd7bb15cf8bba8a49d13a3918c/datastorage-0.7.tar.gz | source | sdist | null | false | 3d0f4394a33829a3f52d8689ab22c0fb | 452d18fe049fbb859422a475db1e10644fc7257e6d3f924f06d68c37fa6d8e15 | af41a36ab236e25a30758b5ca2b0269f882588dd7bb15cf8bba8a49d13a3918c | null | [
"LICENSE"
] | 228 |
2.4 | dataimport-aicare | 0.1.8 | Small package for frequently used functions for the AI-CARE dataset | # Dataimport_AICARE
Submodule for frequently used data loading and preprocessing methods inside of the AI-CARE project.
To include it in your project use ```pip install dataimport-aicare```.
| text/markdown | null | Sebastian Germer <sebastian.germer@dfki.de>, Nina Cassandra Wiegers <nina.wiegers@dfki.de> | null | null | null | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"pandas>=2.3.2",
"scikit-learn>=1.7.1",
"ydata-profiling>=4.16.1"
] | [] | [] | [] | [
"Repository, https://github.com/AI-CARE-Consortium/dataimport_aicare"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:22:41.140633 | dataimport_aicare-0.1.8.tar.gz | 83,774 | af/d5/2c2de2398097bc276c3e118069d3d205b588337f9513f8915d912c887956/dataimport_aicare-0.1.8.tar.gz | source | sdist | null | false | ebc76fbc9b7aece6b7560ed0970830a7 | 46232faadfe487285c7d1a5c38c303423231b9d035fe4d7b84f356dffaffd842 | afd52c2de2398097bc276c3e118069d3d205b588337f9513f8915d912c887956 | MIT | [
"LICENSE"
] | 192 |
2.3 | stigg | 0.1.0a8 | The official Python library for the stigg API | # Stigg Python API library
<!-- prettier-ignore -->
[)](https://pypi.org/project/stigg/)
The Stigg Python library provides convenient access to the Stigg 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/).
## MCP Server
Use the Stigg MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.
[](https://cursor.com/en-US/install-mcp?name=%40stigg%2Ftypescript-mcp&config=eyJuYW1lIjoiQHN0aWdnL3R5cGVzY3JpcHQtbWNwIiwidHJhbnNwb3J0IjoiaHR0cCIsInVybCI6Imh0dHBzOi8vc3RpZ2ctbWNwLnN0bG1jcC5jb20iLCJoZWFkZXJzIjp7IlgtQVBJLUtFWSI6Ik15IEFQSSBLZXkifX0)
[](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22%40stigg%2Ftypescript-mcp%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fstigg-mcp.stlmcp.com%22%2C%22headers%22%3A%7B%22X-API-KEY%22%3A%22My%20API%20Key%22%7D%7D)
> Note: You may need to set environment variables in your MCP client.
## Documentation
The full API of this library can be found in [api.md](https://github.com/stiggio/stigg-python/tree/main/api.md).
## Installation
```sh
# install from PyPI
pip install '--pre stigg'
```
## Usage
The full API of this library can be found in [api.md](https://github.com/stiggio/stigg-python/tree/main/api.md).
```python
import os
from stigg import Stigg
client = Stigg(
api_key=os.environ.get("STIGG_API_KEY"), # This is the default and can be omitted
)
customer_response = client.v1.customers.retrieve(
"REPLACE_ME",
)
print(customer_response.data)
```
While you can provide an `api_key` keyword argument,
we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
to add `STIGG_API_KEY="My API Key"` to your `.env` file
so that your API Key is not stored in source control.
## Async usage
Simply import `AsyncStigg` instead of `Stigg` and use `await` with each API call:
```python
import os
import asyncio
from stigg import AsyncStigg
client = AsyncStigg(
api_key=os.environ.get("STIGG_API_KEY"), # This is the default and can be omitted
)
async def main() -> None:
customer_response = await client.v1.customers.retrieve(
"REPLACE_ME",
)
print(customer_response.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 '--pre stigg[aiohttp]'
```
Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
```python
import os
import asyncio
from stigg import DefaultAioHttpClient
from stigg import AsyncStigg
async def main() -> None:
async with AsyncStigg(
api_key=os.environ.get("STIGG_API_KEY"), # This is the default and can be omitted
http_client=DefaultAioHttpClient(),
) as client:
customer_response = await client.v1.customers.retrieve(
"REPLACE_ME",
)
print(customer_response.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`.
## Pagination
List methods in the Stigg API are paginated.
This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:
```python
from stigg import Stigg
client = Stigg()
all_customers = []
# Automatically fetches more pages as needed.
for customer in client.v1.customers.list(
limit=30,
):
# Do something with customer here
all_customers.append(customer)
print(all_customers)
```
Or, asynchronously:
```python
import asyncio
from stigg import AsyncStigg
client = AsyncStigg()
async def main() -> None:
all_customers = []
# Iterate through items across all pages, issuing requests as needed.
async for customer in client.v1.customers.list(
limit=30,
):
all_customers.append(customer)
print(all_customers)
asyncio.run(main())
```
Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:
```python
first_page = await client.v1.customers.list(
limit=30,
)
if first_page.has_next_page():
print(f"will fetch next page using these details: {first_page.next_page_info()}")
next_page = await first_page.get_next_page()
print(f"number of items we just fetched: {len(next_page.data)}")
# Remove `await` for non-async usage.
```
Or just work directly with the returned data:
```python
first_page = await client.v1.customers.list(
limit=30,
)
print(f"next page cursor: {first_page.pagination.next}") # => "next page cursor: ..."
for customer in first_page.data:
print(customer.id)
# Remove `await` for non-async usage.
```
## Nested params
Nested parameters are dictionaries, typed using `TypedDict`, for example:
```python
from stigg import Stigg
client = Stigg()
page = client.v1.customers.list(
created_at={},
)
print(page.data)
```
## 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 `stigg.APIConnectionError` is raised.
When the API returns a non-success status code (that is, 4xx or 5xx
response), a subclass of `stigg.APIStatusError` is raised, containing `status_code` and `response` properties.
All errors inherit from `stigg.APIError`.
```python
import stigg
from stigg import Stigg
client = Stigg()
try:
client.v1.customers.retrieve(
"REPLACE_ME",
)
except stigg.APIConnectionError as e:
print("The server could not be reached")
print(e.__cause__) # an underlying Exception, likely raised within httpx.
except stigg.RateLimitError as e:
print("A 429 status code was received; we should back off a bit.")
except stigg.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 stigg import Stigg
# Configure the default for all requests:
client = Stigg(
# default is 2
max_retries=0,
)
# Or, configure per-request:
client.with_options(max_retries=5).v1.customers.retrieve(
"REPLACE_ME",
)
```
### 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 stigg import Stigg
# Configure the default for all requests:
client = Stigg(
# 20 seconds (default is 1 minute)
timeout=20.0,
)
# More granular control:
client = Stigg(
timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)
# Override per-request:
client.with_options(timeout=5.0).v1.customers.retrieve(
"REPLACE_ME",
)
```
On timeout, an `APITimeoutError` is thrown.
Note that requests that time out are [retried twice by default](https://github.com/stiggio/stigg-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 `STIGG_LOG` to `info`.
```shell
$ export STIGG_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 stigg import Stigg
client = Stigg()
response = client.v1.customers.with_raw_response.retrieve(
"REPLACE_ME",
)
print(response.headers.get('X-My-Header'))
customer = response.parse() # get the object that `v1.customers.retrieve()` would have returned
print(customer.data)
```
These methods return an [`APIResponse`](https://github.com/stiggio/stigg-python/tree/main/src/stigg/_response.py) object.
The async client returns an [`AsyncAPIResponse`](https://github.com/stiggio/stigg-python/tree/main/src/stigg/_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.v1.customers.with_streaming_response.retrieve(
"REPLACE_ME",
) 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 stigg import Stigg, DefaultHttpxClient
client = Stigg(
# Or use the `STIGG_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 stigg import Stigg
with Stigg() 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/stiggio/stigg-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 stigg
print(stigg.__version__)
```
## Requirements
Python 3.9 or higher.
## Contributing
See [the contributing documentation](https://github.com/stiggio/stigg-python/tree/main/./CONTRIBUTING.md).
| text/markdown | Stigg | null | 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/stiggio/stigg-python",
"Repository, https://github.com/stiggio/stigg-python"
] | twine/5.1.1 CPython/3.12.9 | 2026-02-20T14:22:17.469498 | stigg-0.1.0a8.tar.gz | 168,931 | 7c/ba/6f030d3634b2a6958ed197e0dfd6b8f5d5aa504e44c463bdef4c03e8c465/stigg-0.1.0a8.tar.gz | source | sdist | null | false | 495ee227f8f2db03250c14c0b5cef927 | b1553ea48bd9f5eb43b5b53f05fa63f700e0fa59660958c441c04c4dc93e90e6 | 7cba6f030d3634b2a6958ed197e0dfd6b8f5d5aa504e44c463bdef4c03e8c465 | null | [] | 182 |
2.4 | amsdal_models | 0.6.5 | AMSDAL models | # AMSDAL
[](https://pypi.org/project/amsdal_models)
[](https://pypi.org/project/amsdal_models)
-----
**Table of Contents**
- [Installation](#installation)
- [License](#AMSDAL-End-User-License-Agreement)
## Installation
```console
pip install amsdal_models
```
## AMSDAL End User License Agreement
**Version:** 1.0
**Last Updated:** October 31, 2023
### PREAMBLE
This Agreement is a legally binding agreement between you and AMSDAL regarding the Library. Read this Agreement carefully before accepting it, or downloading or using the Library.
By downloading, installing, running, executing, or otherwise using the Library, by paying the License Fees, or by explicitly accepting this Agreement, whichever is earlier, you agree to be bound by this Agreement without modifications or reservations.
If you do not agree to be bound by this Agreement, you shall not download, install, run, execute, accept, use or permit others to download, install, run, execute, accept, or otherwise use the Library.
If you are acting for or on behalf of an entity, then you accept this Agreement on behalf of such entity and you hereby represent that you are authorized to accept this Agreement and enter into a binding agreement with us on such entity’s behalf.
1. **INTERPRETATION**
1.1. The following definitions shall apply, unless otherwise expressly stated in this Agreement:
“**Additional Agreement**” means a written agreement executed between you and us that supplements and/or modifies this Agreement by specifically referring hereto.
“**Agreement**” means this AMSDAL End User License Agreement as may be updated or supplemented from time to time.
“**AMSDAL**”, “**we**”, “**us**” means AMSDAL INC., a Delaware corporation having its principal place of business in the State of New York.
“**Communications**” means all and any notices, requests, demands and other communications required or may be given under the terms of this Agreement or in connection herewith.
“**Consumer**” means, unless otherwise defined under the applicable legislation, a person who purchases or uses goods or services for personal, family, or household purposes.
“**Documentation**” means the technical, user, or other documentation, as may be updated from time to time, such as manuals, guidelines, which is related to the Library and provided or distributed by us or on our behalf, if any.
“**Free License Plan**” means the License Plan that is provided free of charge, with no License Fee due.
“**Library**” means the AMSDAL Framework and its components, as may be updated from time to time, including the packages: amsdal_Framework and its dependencies amsdal_models, amsdal_data, amsdal_cli, amsdal_server and amsdal_utils.
“**License Fee**” means the consideration to be paid by you to us for the License as outlined herein.
“**License Plan**” means a predetermined set of functionality, restrictions, or services applicable to the Library.
“**License**” has the meaning outlined in Clause 2.1.
“**Parties**” means AMSDAL and you.
“**Party**” means either AMSDAL or you.
“**Product Page**” means our website page related to the Library, if any.
“**Third-Party Materials**” means the code, software or other content that is distributed by third parties under free or open-source software licenses (such as MIT, Apache 2.0, BSD) that allow for editing, modifying, or reusing such content.
“**Update**” means an update, patch, fix, support release, modification, or limited functional enhancement to the Library, including but not limited to error corrections to the Library, which does not, in our opinion, constitute an upgrade or a new/separate product.
“**U.S. Export Laws**” means the United States Export Administration Act and any other export law, restriction, or regulation.
“**Works**” means separate works, such as software, that are developed using the Library. The Works should not merely be a fork, alternative, copy, or derivative work of the Library or its part.
“**You**” means either you as a single individual or a single entity you represent.
1.2. Unless the context otherwise requires, a reference to one gender shall include a reference to the other genders; words in the singular shall include the plural and in the plural shall include the singular; any words following the terms including, include, in particular, for example, or any similar expression shall be construed as illustrative and shall not limit the sense of the words, description, definition, phrase or term preceding those terms; except where a contrary intention appears, a reference to a Section or Clause is a reference to a Section or Clause of this Agreement; Section and Clause headings do not affect the interpretation of this Agreement.
1.3. Each provision of this Agreement shall be construed as though both Parties participated equally in the drafting of same, and any rule of construction that a document shall be construed against the drafting Party, including without limitation, the doctrine is commonly known as “*contra proferentem*”, shall not apply to the interpretation of this Agreement.
2. **LICENSE, RESTRICTIONS**
2.1. License Grant. Subject to the terms and conditions contained in this Agreement, AMSDAL hereby grants to you a non-exclusive, non-transferable, revocable, limited, worldwide, and non-sublicensable license (the “**License**”) to install, run, and use the Library, as well as to modify and customize the Library to implement it in the Works.
2.2. Restrictions. As per the License, you shall not, except as expressly permitted herein, (i) sell, resell, transfer, assign, pledge, rent, rent out, lease, assign, distribute, copy, or encumber the Library or the rights in the Library, (ii) use the Library other than as expressly authorized in this Agreement, (iii) remove any copyright notice, trademark notice, and/or other proprietary legend or indication of confidentiality set forth on or contained in the Library, if any, (iv) use the Library in any manner that violates the laws of the United States of America or any other applicable law, (v) circumvent any feature, key, or other licensing control mechanism related to the Library that ensures compliance with this Agreement, (vi) reverse engineer, decompile, disassemble, decrypt or otherwise seek to obtain the source code to the Library, (vii) with respect to the Free License Plan, use the Library to provide a service to a third party, and (viii) permit others to do anything from the above.
2.3. Confidentiality. The Library, including any of its elements and components, shall at all times be treated by you as confidential and proprietary. You shall not disclose, transfer, or otherwise share the Library to any third party without our prior written consent. You shall also take all reasonable precautions to prevent any unauthorized disclosure and, in any event, shall use your best efforts to protect the confidentiality of the Library. This Clause does not apply to the information and part of the Library that (i) is generally known to the public at the time of disclosure, (ii) is legally received by you from a third party which rightfully possesses such information, (iii) becomes generally known to the public subsequent to the time of such disclosure, but not as a result of unauthorized disclosure hereunder, (iv) is already in your possession prior to obtaining the Library, or (v) is independently developed by you or on your behalf without use of or reference to the Library.
2.4. Third-Party Materials. By entering into this Agreement, you acknowledge and confirm that the Library includes the Third-Party Materials. The information regarding the Third-Party Materials will be provided to you along with the Library. If and where necessary, you shall comply with the terms and conditions applicable to the Third-Party Materials.
2.5. Title. The Library is protected by law, including without limitation the copyright laws of the United States of America and other countries, and by international treaties. AMSDAL or its licensors reserve all rights not expressly granted to you in this Agreement. You agree that AMSDAL and/or its licensors own all right, title, interest, and intellectual property rights associated with the Library, including related applications, plugins or extensions, and you will not contest such ownership.
2.6. No Sale. The Library provided hereunder is licensed, not sold. Therefore, the Library is exempt from the “first sale” doctrine, as defined in the United States copyright laws or any other applicable law. For purposes of clarification only, you accept, acknowledge and agree that this is a license agreement and not an agreement for sale, and you shall have no ownership rights in any intellectual or tangible property of AMSDAL or its licensors.
2.7. Works. We do not obtain any rights, title or interest in and to the Works. Once and if the Library components lawfully become a part of the Works, you are free to choose the terms governing the Works. If the License is terminated you shall not use the Library within the Works.
2.8. Statistics. You hereby acknowledge and agree that we reserve the right to track and analyze the Library usage statistics and metrics.
3. **LICENSE PLANS**
3.1. Plans. The Library, as well as its functionality and associated services, may be subject to certain restrictions and limitations depending on the License Plan. The License Plan’s description, including any terms, such as term, License Fees, features, etc., are or will be provided by us including via the Product Page.
3.2. Plan Change. The Free License Plan is your default License Plan. You may change your License Plan by following our instructions that may be provided on the Product Page or otherwise. Downgrades are available only after the end of the respective prepaid License Plan.
3.3. Validity. You may have only one valid License Plan at a time. The License Plan is valid when it is fully prepaid by you (except for the Free License Plan which is valid only if and as long as we grant the License to you) and this Agreement is not terminated in accordance with the terms hereof.
3.4. Terms Updates. The License Plan’s terms may be updated by us at our sole discretion with or without prior notice to you. The License Plan updates that worsen terms and conditions of your valid License Plan will only be effective for the immediately following License Plan period, if any.
3.5. Free License Plan. We may from time to time at our discretion with or without notice and without liability to you introduce, update, suspend, or terminate the Free License Plan. The Free License Plan allows you to determine if the Library suits your particular needs. The Library provided under the Free License Plan is not designed to and shall not be used in trade, commercial activities, or your normal course of business.
4. **PAYMENTS**
4.1. License Fees. In consideration for the License provided hereunder, you shall, except for the Free License Plan, pay the License Fee in accordance with the terms of the chosen License Plan or Additional Agreement, if any.
4.2. Updates. We reserve the right at our sole discretion to change any License Fees, as well as to introduce or change any new payments at any time. The changes will not affect the prepaid License Plans; however they will apply starting from the immediately following License Plan period.
4.3. Payment Terms. Unless otherwise agreed in the Additional Agreement, the License Fees are paid fully in advance.
4.4. Precondition. Except for the Free License Plan, payment of the License Fee shall be the precondition for the License. Therefore, if you fail to pay the License Fee in full in accordance with the terms hereof, this Agreement, as well as the License, shall immediately terminate.
4.5. Currency and Fees. Unless expressly provided, prices are quoted in U.S. dollars. All currency conversion fees shall be paid by you. Each Party shall cover its own commissions and fees applicable to the transactions contemplated hereunder.
4.6. Refunds. There shall be no partial or total refunds of the License Fees that were already paid to us, including without limitation if you failed to download or use the Library.
4.7. Taxes. Unless expressly provided, all amounts are exclusive of taxes, including value added tax, sales tax, goods and services tax or other similar tax, each of which, where chargeable by us, shall be payable by you at the rate and in the manner prescribed by law. All other taxes, duties, customs, or similar charges shall be your responsibility.
5. **UPDATES, AVAILABILITY, SUPPORT**
5.1. Updates. Except for the Free License Plan, you are eligible to receive all relevant Updates during the valid License Plan at no additional charge. The Library may be updated at our sole discretion with or without notice to you. However, we shall not be obligated to make any Updates.
5.2. Availability. We do not guarantee that any particular feature or functionality of the Library will be available at any time.
5.3. Support. Unless otherwise decided by us at our sole discretion, we do not provide any support services. There is no representation or warranty that any functionality or Library as such will be supported by us.
5.4. Termination. We reserve the right at our sole discretion to discontinue the Library distribution and support at any time by providing prior notice to you. However, we will continue to maintain the Library until the end of then-current License Plan.
6. **TERM, TERMINATION**
6.1. Term. Unless terminated earlier on the terms outlined herein, this Agreement shall be in force as long as you have a valid License Plan. Once your License Plan expires, this Agreement shall automatically expire.
6.2. Termination Without Cause. You may terminate this Agreement for convenience at any time.
6.3. Termination For Breach. If you are in breach of this Agreement and you fail to promptly, however not later than within ten (10) days, following our notice to cure such breach, we may immediately terminate this Agreement.
6.4. Termination For Material Breach. If you are in material breach of this Agreement, we may immediately terminate this Agreement upon written notice to you.
6.5. Termination of Free License Plan. If you are using the Library under the Free License Plan, this Agreement may be terminated by us at any time with or without notice and without any liability to you.
6.6. Effect of Termination. Once this Agreement is terminated or expired, (i) the License shall terminate or expire, (ii) you shall immediately cease using the Library, (iii) you shall permanently erase the Library and its copies that are in your possession or control, (iv) if technically possible, we will discontinue the Library operation, (v) all our obligations under this Agreement shall cease, and (vi) the License Fees or any other amounts that were paid to us hereunder, if any, shall not be reimbursed.
6.7. Survival. Clauses and Sections 2.2-2.5, 4.6, 4.7, 6.6, 6.7, 7.7, 8, 9.2, 10-12 shall survive any termination or expiration of this Agreement regardless of the reason.
7. **REPRESENTATIONS, WARRANTIES**
7.1. Mutual Representation. Each Party represents that it has the legal power and authority to enter into this Agreement. If you act on behalf of an entity, you hereby represent that you are authorized to accept this Agreement and enter into a binding agreement with us on such entity’s behalf.
7.2. Not a Consumer. You represent that you are not entering into this Agreement as a Consumer and that you do not intend to use the Library as a Consumer. The Library is not intended to be used by Consumers, therefore you shall not enter into this Agreement, and download and use the Library if you act as a Consumer.
7.3. Sanctions and Restrictions. You represent that you are not (i) a citizen or resident of, or person subject to jurisdiction of, Iran, Syria, Venezuela, Cuba, North Korea, or Russia, or (ii) a person subject to any sanctions administered or enforced by the United States Office of Foreign Assets Control or United Nations Security Council.
7.4. IP Warranty. Except for the Free License Plan, we warrant that, to our knowledge, the Library does not violate or infringe any third-party intellectual property rights, including copyright, rights in patents, trade secrets, and/or trademarks, and that to our knowledge no legal action has been taken in relation to the Library for any infringement or violation of any third party intellectual property rights.
7.5. No Harmful Code Warranty. Except for the Free License Plan, we warrant that we will use commercially reasonable efforts to protect the Library from, and the Library shall not knowingly include, malware, viruses, trap doors, back doors, or other means or functions which will detrimentally interfere with or otherwise adversely affect your use of the Library or which will damage or destroy your data or other property. You represent that you will use commercially reasonable efforts and industry standard tools to prevent the introduction of, and you will not knowingly introduce, viruses, malicious code, malware, trap doors, back doors or other means or functions by accessing the Library, the introduction of which may detrimentally interfere with or otherwise adversely affect the Library or which will damage or destroy data or other property.
7.6. Documentation Compliance Warranty. Except for the Free License Plan, we warrant to you that as long as you maintain a valid License Plan the Library shall perform substantially in accordance with the Documentation. Your exclusive remedy, and our sole liability, with respect to any breach of this warranty, will be for us to use commercially reasonable efforts to promptly correct the non-compliance (provided that you promptly notify us in writing and allow us a reasonable cure period).
7.7. Disclaimer of Warranties. Except for the warranties expressly stated above in this Section, the Library is provided “as is”, with all faults and deficiencies. We disclaim all warranties, express or implied, including, but not limited to, warranties of merchantability, fitness for a particular purpose, title, availability, error-free or uninterrupted operation, and any warranties arising from course of dealing, course of performance, or usage of trade to the extent that we may not as a matter of applicable law disclaim any implied warranty, the scope, and duration of such warranty will be the minimum permitted under applicable law.
8. **LIABILITY**
8.1. Limitation of Liability. To the maximum extent permitted by applicable law, in no event shall AMSDAL be liable under any theory of liability for any indirect, incidental, special, or consequential damages of any kind (including, without limitation, any such damages arising from breach of contract or warranty or from negligence or strict liability), including, without limitation, loss of profits, revenue, data, or use, or for interrupted communications or damaged data, even if AMSDAL has been advised or should have known of the possibility of such damages.
8.2. Liability Cap. In any event, our aggregate liability under this Agreement, negligence, strict liability, or other theory, at law or in equity, will be limited to the total License Fees paid by you under this Agreement for the License Plan valid at the time when the relevant event happened.
8.3. Force Majeure. Neither Party shall be held liable for non-performance or undue performance of this Agreement caused by force majeure. Force majeure means an event or set of events, which is unforeseeable, unavoidable, and beyond control of the respective Party, for instance fire, flood, hostilities, declared or undeclared war, military actions, revolutions, act of God, explosion, strike, embargo, introduction of sanctions, act of government, act of terrorism.
8.4. Exceptions. Nothing contained herein limits our liability to you in the event of death, personal injury, gross negligence, willful misconduct, or fraud.
8.5. Remedies. In addition to, and not in lieu of the termination provisions set forth in Section 6 above, you agree that, in the event of a threatened or actual breach of a provision of this Agreement by you, (i) monetary damages alone will be an inadequate remedy, (ii) such breach will cause AMSDAL great, immediate, and irreparable injury and damage, and (iii) AMSDAL shall be entitled to seek and obtain, from any court of competent jurisdiction (without the requirement of the posting of a bond, if applicable), immediate injunctive and other equitable relief in addition to, and not in lieu of, any other rights or remedies that AMSDAL may have under applicable laws.
9. **INDEMNITY**
9.1. Our Indemnity. Except for the Free License Plan users, we will defend, indemnify, and hold you harmless from any claim, suit, or action to you based on our alleged violation of the IP Warranty provided in Clause 7.4 above, provided you (i) notify us in writing promptly upon notice of such claim and (ii) cooperate fully in the defense of such claim, suit, or action. We shall, at our own expense, defend such a claim, suit, or action, and you shall have the right to participate in the defense at your own expense. For the Free License Plan users, you shall use at your own risk and expense, and we have no indemnification obligations.
9.2. Your Indemnity. You will defend, indemnify, and hold us harmless from any claim, suit, or action to us based on your alleged violation of this Agreement, provided we notify you in writing promptly upon notice of such claim, suit, or action. You shall, at your own expense, defend such a claim, suit, or action.
10. **GOVERNING LAW, DISPUTE RESOLUTION**
10.1. Law. This Agreement shall be governed by the laws of the State of New York, USA, without reference to conflicts of laws principles. Provisions of the United Nations Convention on the International Sale of Goods shall not apply to this Agreement.
10.2. Negotiations. The Parties shall seek to solve amicably any disputes, controversies, claims, or demands arising out of or relating to this Agreement, as well as those related to execution, breach, termination, or invalidity hereof. If the Parties do not reach an amicable resolution within thirty (30) days, any dispute, controversy, claim or demand shall be finally settled by the competent court as outlined below.
10.3. Jurisdiction. The Parties agree that the exclusive jurisdiction and venue for any dispute arising out of or related to this Agreement shall be the courts of the State of New York and the courts of the United States of America sitting in the County of New York.
10.4. Class Actions Waiver. The Parties agree that any dispute arising out of or related to this Agreement shall be pursued individually. Neither Party shall act as a plaintiff or class member in any supposed purported class or representative proceeding, including, but not limited to, a federal or state class action lawsuit, against the other Party in relation herewith.
10.5. Costs. In the event of any legal proceeding between the Parties arising out of or related to this Agreement, the prevailing Party shall be entitled to recover, in addition to any other relief awarded or granted, its reasonable costs and expenses (including attorneys’ and expert witness’ fees) incurred in such proceeding.
11. **COMMUNICATION**
11.1. Communication Terms. Any Communications shall be in writing. When sent by ordinary mail, Communication shall be sent by personal delivery, by certified or registered mail, and shall be deemed delivered upon receipt by the recipient. When sent by electronic mail (email), Communication shall be deemed delivered on the day following the day of transmission. Any Communication given by email in accordance with the terms hereof shall be of full legal force and effect.
11.2. Contact Details. Your contact details must be provided by you to us. AMSDAL contact details are as follows: PO Box 940, Bedford, NY 10506; ams@amsdal.com. Either Party shall keep its contact details correct and up to date. Either Party may update its contact details by providing a prior written notice to the other Party in accordance with the terms hereof.
12. **MISCELLANEOUS**
12.1. Export Restrictions. The Library originates from the United States of America and may be subject to the United States export administration regulations. You agree that you will not (i) transfer or export the Library into any country or (ii) use the Library in any manner prohibited by the U.S. Export Laws. You shall comply with the U.S. Export Laws, as well as all applicable international and national laws related to the export or import regulations that apply in relation to your use of the Library.
12.2. Entire Agreement. This Agreement shall constitute the entire agreement between the Parties, supersede and extinguish all previous agreements, promises, assurances, warranties, representations and understandings between them, whether written or oral, relating to its subject matter.
12.3. Additional Agreements. AMSDAL and you are free to enter into any Additional Agreements. In the event of conflict, unless otherwise explicitly stated, the Additional Agreement shall control.
12.4. Modifications. We may modify, supplement or update this Agreement from time to time at our sole and absolute discretion. If we make changes to this Agreement, we will (i) update the “Version” and “Last Updated” date at the top of this Agreement and (ii) notify you in advance before the changes become effective. Your continued use of the Library is deemed acceptance of the amended Agreement. If you do not agree to any part of the amended Agreement, you shall immediately discontinue any use of the Library, which shall be your sole remedy.
12.5. Assignment. You shall not assign or transfer any rights or obligations under this Agreement without our prior written consent. We may upon prior written notice unilaterally transfer or assign this Agreement, including any rights and obligations hereunder at any time and no such transfer or assignment shall require your additional consent or approval.
12.6. Severance. If any provision or part-provision of this Agreement is or becomes invalid, illegal or unenforceable, it shall be deemed modified to the minimum extent necessary to make it valid, legal, and enforceable. If such modification is not possible, the relevant provision or part-provision shall be deemed deleted. If any provision or part-provision of this Agreement is deemed deleted under the previous sentence, AMSDAL will in good faith replace such provision with a new one that, to the greatest extent possible, achieves the intended commercial result of the original provision. Any modification to or deletion of a provision or part-provision under this Clause shall not affect the validity and enforceability of the rest of this Agreement.
12.7. Waiver. No failure or delay by a Party to exercise any right or remedy provided under this Agreement or by law shall constitute a waiver of that or any other right or remedy, nor shall it preclude or restrict the further exercise of that or any other right or remedy.
12.8. No Partnership or Agency. Nothing in this Agreement is intended to, or shall be deemed to, establish any partnership, joint venture or employment relations between the Parties, constitute a Party the agent of another Party, or authorize a Party to make or enter into any commitments for or on behalf of any other Party.
| text/markdown | null | null | null | null | AMSDAL End User License Agreement
Version: 1.0
Last Updated: October 31, 2023
PREAMBLE
This Agreement is a legally binding agreement between you and AMSDAL regarding the Library. Read this Agreement carefully before accepting it, or downloading or using the Library.
By downloading, installing, running, executing, or otherwise using the Library, by paying the License Fees, or by explicitly accepting this Agreement, whichever is earlier, you agree to be bound by this Agreement without modifications or reservations.
If you do not agree to be bound by this Agreement, you shall not download, install, run, execute, accept, use or permit others to download, install, run, execute, accept, or otherwise use the Library.
If you are acting for or on behalf of an entity, then you accept this Agreement on behalf of such entity and you hereby represent that you are authorized to accept this Agreement and enter into a binding agreement with us on such entity’s behalf.
1. INTERPRETATION
1.1. The following definitions shall apply, unless otherwise expressly stated in this Agreement:
“Additional Agreement” means a written agreement executed between you and us that supplements and/or modifies this Agreement by specifically referring hereto.
“Agreement” means this AMSDAL End User License Agreement as may be updated or supplemented from time to time.
“AMSDAL”, “we”, “us” means AMSDAL INC., a Delaware corporation having its principal place of business in the State of New York.
“Communications” means all and any notices, requests, demands and other communications required or may be given under the terms of this Agreement or in connection herewith.
“Consumer” means, unless otherwise defined under the applicable legislation, a person who purchases or uses goods or services for personal, family, or household purposes.
“Documentation” means the technical, user, or other documentation, as may be updated from time to time, such as manuals, guidelines, which is related to the Library and provided or distributed by us or on our behalf, if any.
“Free License Plan” means the License Plan that is provided free of charge, with no License Fee due.
“Library” means the AMSDAL Framework and its components, as may be updated from time to time, including the packages: amsdal_Framework and its dependencies amsdal_models, amsdal_data, amsdal_cli, amsdal_server and amsdal_utils.
“License Fee” means the consideration to be paid by you to us for the License as outlined herein.
“License Plan” means a predetermined set of functionality, restrictions, or services applicable to the Library.
“License” has the meaning outlined in Clause 2.1.
“Parties” means AMSDAL and you.
“Party” means either AMSDAL or you.
“Product Page” means our website page related to the Library, if any.
“Third-Party Materials” means the code, software or other content that is distributed by third parties under free or open-source software licenses (such as MIT, Apache 2.0, BSD) that allow for editing, modifying, or reusing such content.
“Update” means an update, patch, fix, support release, modification, or limited functional enhancement to the Library, including but not limited to error corrections to the Library, which does not, in our opinion, constitute an upgrade or a new/separate product.
“U.S. Export Laws” means the United States Export Administration Act and any other export law, restriction, or regulation.
“Works” means separate works, such as software, that are developed using the Library. The Works should not merely be a fork, alternative, copy, or derivative work of the Library or its part.
“You” means either you as a single individual or a single entity you represent.
1.2. Unless the context otherwise requires, a reference to one gender shall include a reference to the other genders; words in the singular shall include the plural and in the plural shall include the singular; any words following the terms including, include, in particular, for example, or any similar expression shall be construed as illustrative and shall not limit the sense of the words, description, definition, phrase or term preceding those terms; except where a contrary intention appears, a reference to a Section or Clause is a reference to a Section or Clause of this Agreement; Section and Clause headings do not affect the interpretation of this Agreement.
1.3. Each provision of this Agreement shall be construed as though both Parties participated equally in the drafting of same, and any rule of construction that a document shall be construed against the drafting Party, including without limitation, the doctrine is commonly known as “contra proferentem”, shall not apply to the interpretation of this Agreement.
2. LICENSE, RESTRICTIONS
2.1. License Grant. Subject to the terms and conditions contained in this Agreement, AMSDAL hereby grants to you a non-exclusive, non-transferable, revocable, limited, worldwide, and non-sublicensable license (the “License”) to install, run, and use the Library, as well as to modify and customize the Library to implement it in the Works.
2.2. Restrictions. As per the License, you shall not, except as expressly permitted herein, (i) sell, resell, transfer, assign, pledge, rent, rent out, lease, assign, distribute, copy, or encumber the Library or the rights in the Library, (ii) use the Library other than as expressly authorized in this Agreement, (iii) remove any copyright notice, trademark notice, and/or other proprietary legend or indication of confidentiality set forth on or contained in the Library, if any, (iv) use the Library in any manner that violates the laws of the United States of America or any other applicable law, (v) circumvent any feature, key, or other licensing control mechanism related to the Library that ensures compliance with this Agreement, (vi) reverse engineer, decompile, disassemble, decrypt or otherwise seek to obtain the source code to the Library, (vii) with respect to the Free License Plan, use the Library to provide a service to a third party, and (viii) permit others to do anything from the above.
2.3. Confidentiality. The Library, including any of its elements and components, shall at all times be treated by you as confidential and proprietary. You shall not disclose, transfer, or otherwise share the Library to any third party without our prior written consent. You shall also take all reasonable precautions to prevent any unauthorized disclosure and, in any event, shall use your best efforts to protect the confidentiality of the Library. This Clause does not apply to the information and part of the Library that (i) is generally known to the public at the time of disclosure, (ii) is legally received by you from a third party which rightfully possesses such information, (iii) becomes generally known to the public subsequent to the time of such disclosure, but not as a result of unauthorized disclosure hereunder, (iv) is already in your possession prior to obtaining the Library, or (v) is independently developed by you or on your behalf without use of or reference to the Library.
2.4. Third-Party Materials. By entering into this Agreement, you acknowledge and confirm that the Library includes the Third-Party Materials. The information regarding the Third-Party Materials will be provided to you along with the Library. If and where necessary, you shall comply with the terms and conditions applicable to the Third-Party Materials.
2.5. Title. The Library is protected by law, including without limitation the copyright laws of the United States of America and other countries, and by international treaties. AMSDAL or its licensors reserve all rights not expressly granted to you in this Agreement. You agree that AMSDAL and/or its licensors own all right, title, interest, and intellectual property rights associated with the Library, including related applications, plugins or extensions, and you will not contest such ownership.
2.6. No Sale. The Library provided hereunder is licensed, not sold. Therefore, the Library is exempt from the “first sale” doctrine, as defined in the United States copyright laws or any other applicable law. For purposes of clarification only, you accept, acknowledge and agree that this is a license agreement and not an agreement for sale, and you shall have no ownership rights in any intellectual or tangible property of AMSDAL or its licensors.
2.7. Works. We do not obtain any rights, title or interest in and to the Works. Once and if the Library components lawfully become a part of the Works, you are free to choose the terms governing the Works. If the License is terminated you shall not use the Library within the Works.
2.8. Statistics. You hereby acknowledge and agree that we reserve the right to track and analyze the Library usage statistics and metrics.
3. LICENSE PLANS
3.1. Plans. The Library, as well as its functionality and associated services, may be subject to certain restrictions and limitations depending on the License Plan. The License Plan’s description, including any terms, such as term, License Fees, features, etc., are or will be provided by us including via the Product Page.
3.2. Plan Change. The Free License Plan is your default License Plan. You may change your License Plan by following our instructions that may be provided on the Product Page or otherwise. Downgrades are available only after the end of the respective prepaid License Plan.
3.3. Validity. You may have only one valid License Plan at a time. The License Plan is valid when it is fully prepaid by you (except for the Free License Plan which is valid only if and as long as we grant the License to you) and this Agreement is not terminated in accordance with the terms hereof.
3.4. Terms Updates. The License Plan’s terms may be updated by us at our sole discretion with or without prior notice to you. The License Plan updates that worsen terms and conditions of your valid License Plan will only be effective for the immediately following License Plan period, if any.
3.5. Free License Plan. We may from time to time at our discretion with or without notice and without liability to you introduce, update, suspend, or terminate the Free License Plan. The Free License Plan allows you to determine if the Library suits your particular needs. The Library provided under the Free License Plan is not designed to and shall not be used in trade, commercial activities, or your normal course of business.
4. PAYMENTS
4.1. License Fees. In consideration for the License provided hereunder, you shall, except for the Free License Plan, pay the License Fee in accordance with the terms of the chosen License Plan or Additional Agreement, if any.
4.2. Updates. We reserve the right at our sole discretion to change any License Fees, as well as to introduce or change any new payments at any time. The changes will not affect the prepaid License Plans; however they will apply starting from the immediately following License Plan period.
4.3. Payment Terms. Unless otherwise agreed in the Additional Agreement, the License Fees are paid fully in advance.
4.4. Precondition. Except for the Free License Plan, payment of the License Fee shall be the precondition for the License. Therefore, if you fail to pay the License Fee in full in accordance with the terms hereof, this Agreement, as well as the License, shall immediately terminate.
4.5. Currency and Fees. Unless expressly provided, prices are quoted in U.S. dollars. All currency conversion fees shall be paid by you. Each Party shall cover its own commissions and fees applicable to the transactions contemplated hereunder.
4.6. Refunds. There shall be no partial or total refunds of the License Fees that were already paid to us, including without limitation if you failed to download or use the Library.
4.7. Taxes. Unless expressly provided, all amounts are exclusive of taxes, including value added tax, sales tax, goods and services tax or other similar tax, each of which, where chargeable by us, shall be payable by you at the rate and in the manner prescribed by law. All other taxes, duties, customs, or similar charges shall be your responsibility.
5. UPDATES, AVAILABILITY, SUPPORT
5.1. Updates. Except for the Free License Plan, you are eligible to receive all relevant Updates during the valid License Plan at no additional charge. The Library may be updated at our sole discretion with or without notice to you. However, we shall not be obligated to make any Updates.
5.2. Availability. We do not guarantee that any particular feature or functionality of the Library will be available at any time.
5.3. Support. Unless otherwise decided by us at our sole discretion, we do not provide any support services. There is no representation or warranty that any functionality or Library as such will be supported by us.
5.4. Termination. We reserve the right at our sole discretion to discontinue the Library distribution and support at any time by providing prior notice to you. However, we will continue to maintain the Library until the end of then-current License Plan.
6. TERM, TERMINATION
6.1. Term. Unless terminated earlier on the terms outlined herein, this Agreement shall be in force as long as you have a valid License Plan. Once your License Plan expires, this Agreement shall automatically expire.
6.2. Termination Without Cause. You may terminate this Agreement for convenience at any time.
6.3. Termination For Breach. If you are in breach of this Agreement and you fail to promptly, however not later than within ten (10) days, following our notice to cure such breach, we may immediately terminate this Agreement.
6.4. Termination For Material Breach. If you are in material breach of this Agreement, we may immediately terminate this Agreement upon written notice to you.
6.5. Termination of Free License Plan. If you are using the Library under the Free License Plan, this Agreement may be terminated by us at any time with or without notice and without any liability to you.
6.6. Effect of Termination. Once this Agreement is terminated or expired, (i) the License shall terminate or expire, (ii) you shall immediately cease using the Library, (iii) you shall permanently erase the Library and its copies that are in your possession or control, (iv) if technically possible, we will discontinue the Library operation, (v) all our obligations under this Agreement shall cease, and (vi) the License Fees or any other amounts that were paid to us hereunder, if any, shall not be reimbursed.
6.7. Survival. Clauses and Sections 2.2-2.5, 4.6, 4.7, 6.6, 6.7, 7.7, 8, 9.2, 10-12 shall survive any termination or expiration of this Agreement regardless of the reason.
7. REPRESENTATIONS, WARRANTIES
7.1. Mutual Representation. Each Party represents that it has the legal power and authority to enter into this Agreement. If you act on behalf of an entity, you hereby represent that you are authorized to accept this Agreement and enter into a binding agreement with us on such entity’s behalf.
7.2. Not a Consumer. You represent that you are not entering into this Agreement as a Consumer and that you do not intend to use the Library as a Consumer. The Library is not intended to be used by Consumers, therefore you shall not enter into this Agreement, and download and use the Library if you act as a Consumer.
7.3. Sanctions and Restrictions. You represent that you are not (i) a citizen or resident of, or person subject to jurisdiction of, Iran, Syria, Venezuela, Cuba, North Korea, or Russia, or (ii) a person subject to any sanctions administered or enforced by the United States Office of Foreign Assets Control or United Nations Security Council.
7.4. IP Warranty. Except for the Free License Plan, we warrant that, to our knowledge, the Library does not violate or infringe any third-party intellectual property rights, including copyright, rights in patents, trade secrets, and/or trademarks, and that to our knowledge no legal action has been taken in relation to the Library for any infringement or violation of any third party intellectual property rights.
7.5. No Harmful Code Warranty. Except for the Free License Plan, we warrant that we will use commercially reasonable efforts to protect the Library from, and the Library shall not knowingly include, malware, viruses, trap doors, back doors, or other means or functions which will detrimentally interfere with or otherwise adversely affect your use of the Library or which will damage or destroy your data or other property. You represent that you will use commercially reasonable efforts and industry standard tools to prevent the introduction of, and you will not knowingly introduce, viruses, malicious code, malware, trap doors, back doors or other means or functions by accessing the Library, the introduction of which may detrimentally interfere with or otherwise adversely affect the Library or which will damage or destroy data or other property.
7.6. Documentation Compliance Warranty. Except for the Free License Plan, we warrant to you that as long as you maintain a valid License Plan the Library shall perform substantially in accordance with the Documentation. Your exclusive remedy, and our sole liability, with respect to any breach of this warranty, will be for us to use commercially reasonable efforts to promptly correct the non-compliance (provided that you promptly notify us in writing and allow us a reasonable cure period).
7.7. Disclaimer of Warranties. Except for the warranties expressly stated above in this Section, the Library is provided “as is”, with all faults and deficiencies. We disclaim all warranties, express or implied, including, but not limited to, warranties of merchantability, fitness for a particular purpose, title, availability, error-free or uninterrupted operation, and any warranties arising from course of dealing, course of performance, or usage of trade to the extent that we may not as a matter of applicable law disclaim any implied warranty, the scope, and duration of such warranty will be the minimum permitted under applicable law.
8. LIABILITY
8.1. Limitation of Liability. To the maximum extent permitted by applicable law, in no event shall AMSDAL be liable under any theory of liability for any indirect, incidental, special, or consequential damages of any kind (including, without limitation, any such damages arising from breach of contract or warranty or from negligence or strict liability), including, without limitation, loss of profits, revenue, data, or use, or for interrupted communications or damaged data, even if AMSDAL has been advised or should have known of the possibility of such damages.
8.2. Liability Cap. In any event, our aggregate liability under this Agreement, negligence, strict liability, or other theory, at law or in equity, will be limited to the total License Fees paid by you under this Agreement for the License Plan valid at the time when the relevant event happened.
8.3. Force Majeure. Neither Party shall be held liable for non-performance or undue performance of this Agreement caused by force majeure. Force majeure means an event or set of events, which is unforeseeable, unavoidable, and beyond control of the respective Party, for instance fire, flood, hostilities, declared or undeclared war, military actions, revolutions, act of God, explosion, strike, embargo, introduction of sanctions, act of government, act of terrorism.
8.4. Exceptions. Nothing contained herein limits our liability to you in the event of death, personal injury, gross negligence, willful misconduct, or fraud.
8.5. Remedies. In addition to, and not in lieu of the termination provisions set forth in Section 6 above, you agree that, in the event of a threatened or actual breach of a provision of this Agreement by you, (i) monetary damages alone will be an inadequate remedy, (ii) such breach will cause AMSDAL great, immediate, and irreparable injury and damage, and (iii) AMSDAL shall be entitled to seek and obtain, from any court of competent jurisdiction (without the requirement of the posting of a bond, if applicable), immediate injunctive and other equitable relief in addition to, and not in lieu of, any other rights or remedies that AMSDAL may have under applicable laws.
9. INDEMNITY
9.1. Our Indemnity. Except for the Free License Plan users, we will defend, indemnify, and hold you harmless from any claim, suit, or action to you based on our alleged violation of the IP Warranty provided in Clause 7.4 above, provided you (i) notify us in writing promptly upon notice of such claim and (ii) cooperate fully in the defense of such claim, suit, or action. We shall, at our own expense, defend such a claim, suit, or action, and you shall have the right to participate in the defense at your own expense. For the Free License Plan users, you shall use at your own risk and expense, and we have no indemnification obligations.
9.2. Your Indemnity. You will defend, indemnify, and hold us harmless from any claim, suit, or action to us based on your alleged violation of this Agreement, provided we notify you in writing promptly upon notice of such claim, suit, or action. You shall, at your own expense, defend such a claim, suit, or action.
10. GOVERNING LAW, DISPUTE RESOLUTION
10.1. Law. This Agreement shall be governed by the laws of the State of New York, USA, without reference to conflicts of laws principles. Provisions of the United Nations Convention on the International Sale of Goods shall not apply to this Agreement.
10.2. Negotiations. The Parties shall seek to solve amicably any disputes, controversies, claims, or demands arising out of or relating to this Agreement, as well as those related to execution, breach, termination, or invalidity hereof. If the Parties do not reach an amicable resolution within thirty (30) days, any dispute, controversy, claim or demand shall be finally settled by the competent court as outlined below.
10.3. Jurisdiction. The Parties agree that the exclusive jurisdiction and venue for any dispute arising out of or related to this Agreement shall be the courts of the State of New York and the courts of the United States of America sitting in the County of New York.
10.4. Class Actions Waiver. The Parties agree that any dispute arising out of or related to this Agreement shall be pursued individually. Neither Party shall act as a plaintiff or class member in any supposed purported class or representative proceeding, including, but not limited to, a federal or state class action lawsuit, against the other Party in relation herewith.
10.5. Costs. In the event of any legal proceeding between the Parties arising out of or related to this Agreement, the prevailing Party shall be entitled to recover, in addition to any other relief awarded or granted, its reasonable costs and expenses (including attorneys’ and expert witness’ fees) incurred in such proceeding.
11. COMMUNICATION
11.1. Communication Terms. Any Communications shall be in writing. When sent by ordinary mail, Communication shall be sent by personal delivery, by certified or registered mail, and shall be deemed delivered upon receipt by the recipient. When sent by electronic mail (email), Communication shall be deemed delivered on the day following the day of transmission. Any Communication given by email in accordance with the terms hereof shall be of full legal force and effect.
11.2. Contact Details. Your contact details must be provided by you to us. AMSDAL contact details are as follows: PO Box 940, Bedford, NY 10506; ams@amsdal.com. Either Party shall keep its contact details correct and up to date. Either Party may update its contact details by providing a prior written notice to the other Party in accordance with the terms hereof.
12. MISCELLANEOUS
12.1. Export Restrictions. The Library originates from the United States of America and may be subject to the United States export administration regulations. You agree that you will not (i) transfer or export the Library into any country or (ii) use the Library in any manner prohibited by the U.S. Export Laws. You shall comply with the U.S. Export Laws, as well as all applicable international and national laws related to the export or import regulations that apply in relation to your use of the Library.
12.2. Entire Agreement. This Agreement shall constitute the entire agreement between the Parties, supersede and extinguish all previous agreements, promises, assurances, warranties, representations and understandings between them, whether written or oral, relating to its subject matter.
12.3. Additional Agreements. AMSDAL and you are free to enter into any Additional Agreements. In the event of conflict, unless otherwise explicitly stated, the Additional Agreement shall control.
12.4. Modifications. We may modify, supplement or update this Agreement from time to time at our sole and absolute discretion. If we make changes to this Agreement, we will (i) update the “Version” and “Last Updated” date at the top of this Agreement and (ii) notify you in advance before the changes become effective. Your continued use of the Library is deemed acceptance of the amended Agreement. If you do not agree to any part of the amended Agreement, you shall immediately discontinue any use of the Library, which shall be your sole remedy.
12.5. Assignment. You shall not assign or transfer any rights or obligations under this Agreement without our prior written consent. We may upon prior written notice unilaterally transfer or assign this Agreement, including any rights and obligations hereunder at any time and no such transfer or assignment shall require your additional consent or approval.
12.6. Severance. If any provision or part-provision of this Agreement is or becomes invalid, illegal or unenforceable, it shall be deemed modified to the minimum extent necessary to make it valid, legal, and enforceable. If such modification is not possible, the relevant provision or part-provision shall be deemed deleted. If any provision or part-provision of this Agreement is deemed deleted under the previous sentence, AMSDAL will in good faith replace such provision with a new one that, to the greatest extent possible, achieves the intended commercial result of the original provision. Any modification to or deletion of a provision or part-provision under this Clause shall not affect the validity and enforceability of the rest of this Agreement.
12.7. Waiver. No failure or delay by a Party to exercise any right or remedy provided under this Agreement or by law shall constitute a waiver of that or any other right or remedy, nor shall it preclude or restrict the further exercise of that or any other right or remedy.
12.8. No Partnership or Agency. Nothing in this Agreement is intended to, or shall be deemed to, establish any partnership, joint venture or employment relations between the Parties, constitute a Party the agent of another Party, or authorize a Party to make or enter into any commitments for or on behalf of any other Party.
| null | [
"Development Status :: 4 - Beta",
"Programming Language :: Python",
"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.14,>=3.11 | [] | [] | [] | [
"astor~=0.8",
"pyruff==0.15.1rc5",
"isort~=6.0",
"pydantic~=2.12",
"pandas~=2.1",
"pydantic-partial~=0.5",
"amsdal_utils==0.6.*",
"amsdal_data==0.6.*"
] | [] | [] | [] | [
"Documentation, https://pypi.org/project/amsdal-data/#readme",
"Issues, https://pypi.org/project/amsdal-data/",
"Source, https://pypi.org/project/amsdal-data/"
] | Hatch/1.16.3 cpython/3.11.13 HTTPX/0.28.1 | 2026-02-20T14:22:06.476308 | amsdal_models-0.6.5-cp312-cp312-macosx_10_13_universal2.whl | 806,584 | b4/f9/472b88d59211aed8d3ca20b90c996bb9c4e268f9e27044654b1c3e7cc61e/amsdal_models-0.6.5-cp312-cp312-macosx_10_13_universal2.whl | cp312 | bdist_wheel | null | false | ecf1d327a18c05c88bcc84bb199dd44e | 5cf6319ecb86dc3656bf6513eb99b0c54a28e65b67b6c5ac305507819f15d68f | b4f9472b88d59211aed8d3ca20b90c996bb9c4e268f9e27044654b1c3e7cc61e | null | [
"LICENSE.txt"
] | 0 |
2.4 | marimushka | 0.3.3 | Export marimo notebooks in style | <div align="center">
# <img src="https://raw.githubusercontent.com/Jebel-Quant/rhiza/main/.rhiza/assets/rhiza-logo.svg" alt="Rhiza Logo" width="30"> marimushka
[](https://pypi.org/project/marimushka/)
[](https://opensource.org/licenses/MIT)
[](https://www.python.org/)
[](https://github.com/jebel-quant/marimushka/actions/workflows/rhiza_release.yml)
[](https://github.com/astral-sh/ruff)
[](https://www.codefactor.io/repository/github/jebel-quant/marimushka)
[](https://jebel-quant.github.io/marimushka/tests/html-coverage/index.html)
[](https://pepy.tech/project/marimushka)
[](https://github.com/jebel-quant/marimushka/stargazers)
Export [marimo](https://marimo.io) notebooks in style.
</div>
## 🚀 Overview
Marimushka is a powerful tool for exporting [marimo](https://marimo.io) notebooks
to HTML/WebAssembly format with custom styling. It helps you create beautiful,
interactive web versions of your marimo notebooks and applications that can be
shared with others or deployed to static hosting services like GitHub Pages.
Marimushka "exports" your marimo notebooks
in a stylish, customizable HTML template, making them accessible to anyone
with a web browser - no Python installation required!
### ✨ Features
- 📊 **Export marimo notebooks** (.py files) to HTML/WebAssembly format
- 🎨 **Customize the output** using Jinja2 templates
- 📱 **Support for both interactive notebooks and standalone applications**
- Notebooks are exported in "edit" mode, allowing code modification
- Apps are exported in "run" mode with hidden code for a clean interface
- 🌐 **Generate an index page** that lists all your notebooks and apps
- 🔄 **Integrate with GitHub Actions** for automated deployment
- 🔍 **Recursive directory scanning** to find all notebooks in a project
- 🧩 **Flexible configuration** with command-line options, Python API, and config files
- 🔒 **Security-first design** with multiple protection layers
- Path traversal protection
- TOCTOU race condition prevention
- DoS protections (file size limits, timeouts, worker bounds)
- Error message sanitization
- Subresource Integrity (SRI) for CDN resources
- Audit logging for security events
- Secure file permissions
## 📋 Requirements
- Python 3.10+
- [marimo](https://marimo.io) (installed automatically as a dependency)
- [uvx](https://docs.astral.sh/uv/guides/tools/) (recommended to bypass installation)
## 📥 Installation
We do not recommend installing the tool locally. Please use
```bash
# install marimushka on the fly
uvx marimushka
# or
uvx marimushka --help
```
## 🛠️ Usage
### Command Line
```bash
# Basic usage (some help is displayed)
uvx marimushka
# Start exporting, get some help first
uvx marimushka export --help
# Do it
uvx marimushka export
# Specify a custom template
uvx marimushka export --template path/to/template.html.j2
# Specify a custom output directory
uvx marimushka export --output my_site
# Specify custom notebook and app directories
uvx marimushka export --notebooks path/to/notebooks --apps path/to/apps
# Disable sandbox mode (use project environment)
uvx marimushka export --no-sandbox
```
### Configuration File
Marimushka supports configuration via a `.marimushka.toml` file in your project root:
```toml
[marimushka]
output = "_site"
notebooks = "notebooks"
apps = "apps"
sandbox = true
parallel = true
max_workers = 4
timeout = 300
[marimushka.security]
audit_enabled = true
audit_log = ".marimushka-audit.log"
max_file_size_mb = 10
file_permissions = "0o644"
```
See `.marimushka.toml.example` in the repository for a complete example with documentation.
### Project Structure
Marimushka recommends your project to have the following structure
to be aligned with its default arguments. However, it is possible
to inject alternative locations
```bash
your-project/
├── notebooks/ # Static marimo notebooks (.py files)
├── notebooks_wasm/ # Interactive marimo notebooks (.py files)
├── apps/ # Marimo applications (.py files)
└── custom-templates/ # Optional: Custom templates for export
└── custom.html.j2 # Your custom template
```
### Marimo Notebook Requirements
By default, marimushka exports notebooks using the `--sandbox` flag.
This ensures that the export process runs in an isolated environment, which is safer and ensures that your notebook's dependencies are correctly defined in the notebook itself (e.g. using `/// script` metadata).
When developing or testing notebooks locally, it is good practice to use the `--sandbox` flag:
```bash
# Running a notebook with the sandbox flag
marimo run your_notebook.py --sandbox
# Or with uvx
uvx marimo run your_notebook.py --sandbox
```
If you need to export notebooks that rely on the local environment (e.g. packages installed in the current venv but not declared in the notebook), you can disable the sandbox:
```bash
uvx marimushka export --no-sandbox
```
### GitHub Action
You can use marimushka in your GitHub Actions workflow to automatically export
and deploy your notebooks:
```yaml
permissions:
contents: read
jobs:
export:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Export marimo notebooks
uses: jebel-quant/marimushka@v0.2.1
with:
template: 'path/to/template.html.j2' # Optional: custom template
notebooks: 'notebooks' # Optional: notebooks directory
apps: 'apps' # Optional: apps directory
notebooks_wasm: 'notebooks' # Optional: interactive notebooks directory
```
The action will create a GitHub artifact named 'marimushka' containing all exported files.
The artifact is available in all jobs further declaring a dependency
on the 'export' job.
#### Action Inputs
| Input | Description | Required | Default |
|-------|-------------|----------|---------|
| `notebooks` | Directory containing marimo notebook files (.py) to be exported as static HTML notebooks. | No | `notebooks` |
| `apps` | Directory containing marimo app files (.py) to be exported as WebAssembly applications with hidden code (run mode). | No | `apps` |
| `notebooks_wasm` | Directory containing marimo notebook files (.py) to be exported as interactive WebAssembly notebooks with editable code (edit mode). | No | `notebooks` |
| `template` | Path to a custom Jinja2 template file (.html.j2) for the index page. If not provided, the default Tailwind CSS template will be used. | No | |
#### Example: Export and Deploy to GitHub Pages
```yaml
name: Export and Deploy
on:
push:
branches: [ main ]
jobs:
export-and-deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Export marimo notebooks
uses: jebel-quant/marimushka@v0.2.1
with:
notebooks: 'notebooks'
apps: 'apps'
- name: Deploy to GitHub Pages
uses: JamesIves/github-pages-deploy-action@v4
with:
folder: artifacts/marimushka
branch: gh-pages
```
### Advanced CI/CD Patterns
#### GitLab CI Integration
Marimushka works seamlessly with GitLab CI/CD:
```yaml
# .gitlab-ci.yml
stages:
- export
- deploy
export-notebooks:
stage: export
image: python:3.11
script:
- pip install uv
- uvx marimushka export --output public
artifacts:
paths:
- public
only:
- main
pages:
stage: deploy
dependencies:
- export-notebooks
script:
- echo "Deploying to GitLab Pages"
artifacts:
paths:
- public
only:
- main
```
#### CircleCI Integration
```yaml
# .circleci/config.yml
version: 2.1
jobs:
export:
docker:
- image: cimg/python:3.11
steps:
- checkout
- run:
name: Install dependencies
command: pip install uv
- run:
name: Export notebooks
command: uvx marimushka export
- persist_to_workspace:
root: .
paths:
- _site
- store_artifacts:
path: _site
destination: notebooks
workflows:
main:
jobs:
- export
```
#### Netlify Integration
Deploy directly to Netlify from GitHub Actions:
```yaml
# .github/workflows/netlify.yml
name: Deploy to Netlify
on:
push:
branches: [main]
pull_request:
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Export notebooks
uses: jebel-quant/marimushka@v0.2.1
- name: Deploy to Netlify
uses: nwtgck/actions-netlify@v2
with:
publish-dir: artifacts/marimushka
production-branch: main
github-token: ${{ secrets.GITHUB_TOKEN }}
deploy-message: "Deploy from GitHub Actions"
env:
NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
```
#### Vercel Integration
Deploy to Vercel using GitHub Actions:
```yaml
# .github/workflows/vercel.yml
name: Deploy to Vercel
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Export notebooks
uses: jebel-quant/marimushka@v0.2.1
- name: Deploy to Vercel
uses: amondnet/vercel-action@v25
with:
vercel-token: ${{ secrets.VERCEL_TOKEN }}
vercel-org-id: ${{ secrets.VERCEL_ORG_ID }}
vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
working-directory: artifacts/marimushka
```
#### AWS S3 + CloudFront
Deploy to AWS infrastructure:
```yaml
# .github/workflows/aws.yml
name: Deploy to AWS
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Export notebooks
uses: jebel-quant/marimushka@v0.2.1
- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v4
with:
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
aws-region: us-east-1
- name: Sync to S3
run: |
aws s3 sync artifacts/marimushka/ s3://${{ secrets.S3_BUCKET }}/notebooks/ \
--delete \
--cache-control "public, max-age=3600"
- name: Invalidate CloudFront
run: |
aws cloudfront create-invalidation \
--distribution-id ${{ secrets.CLOUDFRONT_DIST_ID }} \
--paths "/*"
```
**For more CI/CD recipes and patterns**, see:
- [RECIPES.md](RECIPES.md#cicd-integration) - Comprehensive recipes and examples
- [FAQ.md](FAQ.md#deployment--cicd) - Common deployment questions
- [TROUBLESHOOTING.md](TROUBLESHOOTING.md#github-action-issues) - CI/CD troubleshooting
## 🎨 Customizing Templates
Marimushka uses Jinja2 templates to generate the 'index.html' file.
You can customize the appearance of the index page by creating your own template.
The template has access to two variables:
- `notebooks`: A list of Notebook objects representing regular notebooks
- `apps`: A list of Notebook objects representing app notebooks
- `notebooks_wasm`: A list of Notebook objects representing interactive notebooks
Each Notebook object has the following properties:
- `display_name`: The display name of the notebook (derived from the filename)
- `html_path`: The path to the exported HTML file
- `path`: The original path to the notebook file
- `kind`: The type of the notebook (notebook / apps / notebook_wasm )
Example template structure:
```html
<!DOCTYPE html>
<html>
<head>
<title>My Marimo Notebooks</title>
<style>
/* Your custom CSS here */
</style>
</head>
<body>
<h1>My Notebooks</h1>
{% if notebooks %}
<h2>Interactive Notebooks</h2>
<ul>
{% for notebook in notebooks %}
<li>
<a href="{{ notebook.html_path }}">{{ notebook.display_name }}</a>
</li>
{% endfor %}
</ul>
{% endif %}
{% if apps %}
<h2>Applications</h2>
<ul>
{% for app in apps %}
<li>
<a href="{{ app.html_path }}">{{ app.display_name }}</a>
</li>
{% endfor %}
</ul>
{% endif %}
</body>
</html>
```
## 🔒 Security
Marimushka is designed with security as a priority. See [SECURITY.md](SECURITY.md) for details on:
- Security features and protections
- Best practices for secure deployment
- Configuration options for enhanced security
- Audit logging
- Vulnerability reporting
## 👥 Contributing
Contributions are welcome! Here's how you can contribute:
1. 🍴 Fork the repository
2. 🌿 Create your feature branch (`git checkout -b feature/amazing-feature`)
3. 💾 Commit your changes (`git commit -m 'Add some amazing feature'`)
4. 🚢 Push to the branch (`git push origin feature/amazing-feature`)
5. 🔍 Open a Pull Request
### Development Setup
```bash
# Clone the repository
git clone https://github.com/jebel-quant/marimushka.git
cd marimushka
# Install dependencies
make install
# Run tests
make test
# Run linting and formatting
make fmt
```
## 📚 Documentation
Marimushka has comprehensive documentation to help you get the most out of it:
### Core Documentation
- **[README.md](README.md)** - This file. Getting started guide and feature overview
- **[CHANGELOG.md](CHANGELOG.md)** - Detailed version history with migration notes
- **[MIGRATION.md](docs/MIGRATION.md)** - Version upgrade guides with code examples
- **[API.md](API.md)** - Complete Python API reference for programmatic usage
### User Guides
- **[TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md)** - Common issues and solutions
- Installation problems
- Export failures
- Template errors
- Performance issues
- GitHub Action troubleshooting
- **[RECIPES.md](docs/RECIPES.md)** - Real-world usage patterns and examples
- Basic workflows
- CI/CD integration (GitHub, GitLab, CircleCI)
- Custom templates
- Advanced patterns
- Deployment strategies
- **[FAQ.md](docs/FAQ.md)** - Frequently asked questions
- Quick answers to 50+ common questions
- Organized by topic
- Search-friendly format
### Configuration
- **[.marimushka.toml.example](.marimushka.toml.example)** - Configuration file example
- **[src/marimushka/templates/README.md](src/marimushka/templates/README.md)** - Template customization guide
### Security & Contributing
- **[SECURITY.md](SECURITY.md)** - Security features, best practices, and reporting
- **[CONTRIBUTING.md](CONTRIBUTING.md)** - How to contribute to the project
- **[CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)** - Community guidelines
### Quick Links
| I want to... | See... |
|-------------|--------|
| Get started quickly | [README.md - Installation](#-installation) |
| Fix an error | [TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) |
| See real examples | [RECIPES.md](docs/RECIPES.md) |
| Find a quick answer | [FAQ.md](docs/FAQ.md) |
| Upgrade versions | [MIGRATION.md](docs/MIGRATION.md) |
| Use the Python API | [API.md](API.md) |
| Deploy to GitHub Pages | [README.md - GitHub Action](#github-action) |
| Customize templates | [src/marimushka/templates/README.md](src/marimushka/templates/README.md) |
| Report a security issue | [SECURITY.md](SECURITY.md#reporting-a-vulnerability) |
| Contribute | [CONTRIBUTING.md](CONTRIBUTING.md) |
## 📄 License
This project is licensed under the [MIT License](LICENSE).
## 🙏 Acknowledgements
- [marimo](https://marimo.io) - The reactive Python notebook that powers this project
- [Jinja2](https://jinja.palletsprojects.com/) - The templating engine
used for HTML generation
- [uv](https://github.com/astral-sh/uv) - The fast Python package installer and resolver
| text/markdown | null | Jebel Quant LLC <contact@jqr.ae> | null | null | null | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"jinja2>=3.1.6",
"loguru>=0.7.3",
"rich>=14.0.0",
"typer>=0.16.0",
"watchfiles>=0.21.0; extra == \"watch\""
] | [] | [] | [] | [
"repository, https://github.com/jebel-quant/marimushka"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:21:50.482412 | marimushka-0.3.3.tar.gz | 39,921 | 65/7f/8c7b36543a48ca3f22f0d72eddc78e7a2c8453f2e603a5ee6dd38393394b/marimushka-0.3.3.tar.gz | source | sdist | null | false | fe2e4fdb4679ebebecd07037114ab974 | 9e81f30777ff4901e83d4a89d35ff410ddf0ae56390fddfdd5e8216d65480ce2 | 657f8c7b36543a48ca3f22f0d72eddc78e7a2c8453f2e603a5ee6dd38393394b | null | [
"LICENSE"
] | 365 |
2.4 | boto3-client-cache | 2.0.0 | boto3-client-cache provides a concurrency-safe, bounded cache for boto3 clients with deterministic identity semantics. | # boto3-client-cache
<div align="left">
<a href="https://pypi.org/project/boto3-client-cache/">
<img
src="https://img.shields.io/pypi/v/boto3-client-cache?color=%23FF0000FF&logo=python&label=Latest%20Version"
alt="pypi_version"
/>
</a>
<a href="https://pypi.org/project/boto3-client-cache/">
<img
src="https://img.shields.io/pypi/pyversions/boto3-client-cache?style=pypi&color=%23FF0000FF&logo=python&label=Compatible%20Python%20Versions"
alt="py_version"
/>
</a>
<a href="https://github.com/michaelthomasletts/boto3-client-cache/actions/workflows/push.yml">
<img
src="https://img.shields.io/github/actions/workflow/status/michaelthomasletts/boto3-client-cache/push.yml?logo=github&color=%23FF0000FF&label=Build"
alt="workflow"
/>
</a>
<a href="https://github.com/michaelthomasletts/boto3-client-cache/commits/main">
<img
src="https://img.shields.io/github/last-commit/michaelthomasletts/boto3-client-cache?logo=github&color=%23FF0000FF&label=Last%20Commit"
alt="last_commit"
/>
</a>
<a href="https://michaelthomasletts.com/boto3-client-cache">
<img
src="https://img.shields.io/badge/Official%20Documentation-📘-FF0000?style=flat&labelColor=555&logo=readthedocs"
alt="documentation"
/>
</a>
<a href="https://github.com/michaelthomasletts/boto3-client-cache">
<img
src="https://img.shields.io/badge/Source%20Code-💻-FF0000?style=flat&labelColor=555&logo=github"
alt="github"
/>
</a>
<a href="https://github.com/michaelthomasletts/boto3-client-cache/blob/main/LICENSE">
<img
src="https://img.shields.io/static/v1?label=License&message=Apache&color=FF0000&labelColor=555&logo=github&style=flat"
alt="license"
/>
</a>
<a href="https://github.com/sponsors/michaelthomasletts">
<img
src="https://img.shields.io/badge/Sponsor%20this%20Project-💙-FF0000?style=flat&labelColor=555&logo=githubsponsors"
alt="sponsorship"
/>
</a>
</div>
</br>
## Description
boto3-client-cache provides a concurrency-safe, bounded cache for boto3 client and resource objects with deterministic identity semantics.
LRU and LFU eviction are supported.
## Why this Exists
[boto3 clients and resources consume a large amount of memory](https://github.com/boto/boto3/issues/4568). Many developers never notice this. *At scale*, however, the memory footprint of boto3 clients and resources often becomes clear through manifold consequences. Caching is an obvious choice for managing multiple clients and-or resources at scale.
boto3 does not cache client or resource objects natively. There are also, to my knowledge, no other open-source tools available which do what boto3-client-cache does. To compensate, bespoke caching solutions [circulate online](https://github.com/boto/boto3/issues/1670). boto3-client-cache exists to standardize and democratize client and resource caching for the Python AWS community.
## Design
The most important but challenging design choice for client and resource caching is selecting and enforcing a robust and standardized methodology for unique keys. **boto3-client-cache hashes according to boto3 client and resource signatures**.
Setting and retrieving clients and resources from the client cache therefore requires an explicit declaration of intention -- that is, *the developer must explicitly pass client and resource initialization parameters to a `ClientCacheKey` or `ResourceCacheKey` object in order to set or retrieve boto3 clients*. This ensures setting and retrieving clients and resources are *unambiguous and deterministic* operations. By locking the cache, as boto3-client-cache does, race conditions are prevented, enabling developers to confidently employ the cache at scale with predictable cache eviction behavior. Lastly, by designing the cache like a dict in the standard Python library, the cache is ergonomically familiar and thus easy to use.
These decisions reflect the core design goals of boto3-client-cache: **safety at scale, deterministic behavior, ergonomic interfacing, and explicit identity**.
## Installation
```bash
pip install boto3-client-cache
```
## Quickstart
Refer to the [official documentation](https://michaelthomasletts.com/boto3-client-cache/quickstart.html) for additional information.
```python
from boto3_client_cache import ClientCache, ClientCacheKey
import boto3
# create an LRU client cache with a maximum size of 30
cache = ClientCache(max_size=30)
# store boto3 client params in an object
kwargs = {"service_name": "s3", "region_name": "us-west-2"}
# create a cache key using those params
key = ClientCacheKey(**kwargs)
# assign a client
cache[key] = boto3.client(**kwargs)
# and retrieve that client using the key
s3_client = cache[key]
```
## Error Semantics
Refer to the [official documentation](https://michaelthomasletts.com/boto3-client-cache/quickstart.html) for additional information.
```python
# raises ClientCacheExistsError b/c client(**kwargs) already exists
cache[key] = boto3.client(**kwargs)
# raises ClientCacheNotFoundError b/c the specific client was not cached
cache[ClientCacheKey(service_name="ec2", region_name="us-west-2")]
# returns None instead of raising ClientCacheNotFoundError
cache.get(ClientCacheKey(service_name="ec2", region_name="us-west-2"))
# raises ClientCacheError b/c the key is not a ClientCacheKey
cache["this is not a ClientCacheKey"]
# raises ClientCacheError b/c the object is not a client
cache[ClientCacheKey("s3")] = "this is not a boto3 client"
```
## License
boto3-client-cache is licensed by the [Apache Software License (2.0)](https://github.com/michaelthomasletts/boto3-client-cache/blob/main/LICENSE).
## Contributing
Refer to the [contributing guidelines](https://github.com/michaelthomasletts/boto3-client-cache?tab=contributing-ov-file) for additional information on how to contribute to boto3-client-cache.
## Special Thanks
- [Patrick Sanders](https://github.com/patricksanders)
- [Ben Kehoe](https://github.com/benkehoe)
| text/markdown | null | Mike Letts <lettsmt@gmail.com> | null | Mike Letts <lettsmt@gmail.com> | null | amazon web services, aws, boto, boto3, botocore, cache, client, client cache, lfu cache, lru cache | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"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 :: Security",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"boto3",
"botocore"
] | [] | [] | [] | [
"Homepage, https://michaelthomasletts.com/boto3-client-cache",
"Repository, https://github.com/michaelthomasletts/boto3-client-cache",
"Documentation, https://michaelthomasletts.com/boto3-client-cache"
] | 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-20T14:21:25.353071 | boto3_client_cache-2.0.0-py3-none-any.whl | 20,748 | c0/8e/8afdbda5749d22805d32cfca1a45b9cd3c9afddc8d5d369a84e6f52d9ebf/boto3_client_cache-2.0.0-py3-none-any.whl | py3 | bdist_wheel | null | false | e39ef595a97e7d3086426b958d40c93c | 67befa2abe090da8f45fa20e6313eb8521e961d9ecaf76e073a5706e0ed94d18 | c08e8afdbda5749d22805d32cfca1a45b9cd3c9afddc8d5d369a84e6f52d9ebf | null | [
"LICENSE"
] | 193 |
2.3 | trimes | 0.1.0 | A python package for transient time series | # trimes
*trimes* (transient time series) is a python package for transient time series data in pandas format. The application is actually for all time series data where the time vector has a numerical format (e.g numpy's float64) - as opposed to the frequently used *DateTime* format. To the best of our knowledge, there is currently no other python package focusing on transient time series data as described and the mentioned *DateTime* format is not convenient for transient time series.
trimes provides functionality for pandas DataFrames (in the format mentioned above) for the following use cases:
- get data points
- interpolation
- resampling
- regression
- signal generation (harmonics, symmetrical components)
- comparison of times series (difference, boundaries, envelopes)
- metrics (e.g. root mean squared error)
- step response analysis
- plotting
and more.
Have a look at the [documentation](https://fraunhiee-unikassel-powsysstability.github.io/trimes/docs/index.html) to get started.
## Installation
```shell
pip install trimes
```
| text/markdown | null | Sciemon <simon.eberlein@gmx.de> | null | null | MIT License
Copyright (c) 2024 FraunhIEE-UniKassel-PowSysStability
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 | [
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"control>0.10",
"icecream>=2.1.2",
"matplotlib>3",
"numpy>=2.1.3",
"pandas>=2.2.3"
] | [] | [] | [] | [
"Homepage, https://github.com/FraunhIEE-UniKassel-PowSysStability/trimes",
"Bug Tracker, https://github.com/FraunhIEE-UniKassel-PowSysStability/trimes/issues"
] | twine/6.1.0 CPython/3.11.7 | 2026-02-20T14:21:24.843240 | trimes-0.1.0.tar.gz | 1,635,471 | cb/20/b515f777072a7cedf737655d0ca0c49c697d56aeff1b8eb4c748b19d7daf/trimes-0.1.0.tar.gz | source | sdist | null | false | e0f2ba8dc641ba851bb67d31d491269b | 796af9dd46eedd8831293260d183ee332d2e4f8084e5cb7dc08384557f0ba4b5 | cb20b515f777072a7cedf737655d0ca0c49c697d56aeff1b8eb4c748b19d7daf | null | [] | 193 |
2.4 | apcore | 0.4.0 | Schema-driven module development framework for AI-perceivable interfaces | <div align="center">
<img src="./apcore-logo.svg" alt="apcore logo" width="200"/>
</div>
# apcore
Schema-driven module development framework for AI-perceivable interfaces.
**apcore** provides a unified task orchestration framework with strict type safety, access control, middleware pipelines, and built-in observability. It enables you to define modules with structured input/output schemas that are easily consumed by LLMs and other automated systems.
## Features
- **Schema-driven modules** -- Define input/output contracts using Pydantic models with automatic validation
- **10-step execution pipeline** -- Context creation, safety checks, ACL enforcement, validation, middleware chains, and execution with timeout support
- **`@module` decorator** -- Turn plain functions into fully schema-aware modules with zero boilerplate
- **YAML bindings** -- Register modules declaratively without modifying source code
- **Access control (ACL)** -- Pattern-based, first-match-wins rules with wildcard support
- **Middleware system** -- Composable before/after hooks with error recovery
- **Observability** -- Tracing (spans), metrics collection, and structured context logging
- **Async support** -- Seamless sync and async module execution
- **Safety guards** -- Call depth limits, circular call detection, frequency throttling
## Requirements
- Python >= 3.11
## Installation
```bash
pip install -e .
```
For development:
```bash
pip install -e ".[dev]"
```
## Quick Start
### Define a module with the decorator
```python
from apcore import module
@module(description="Add two integers", tags=["math"])
def add(a: int, b: int) -> int:
return a + b
```
### Define a module with a class
```python
from pydantic import BaseModel
from apcore import Context
class GreetInput(BaseModel):
name: str
class GreetOutput(BaseModel):
message: str
class GreetModule:
input_schema = GreetInput
output_schema = GreetOutput
description = "Greet a user"
def execute(self, inputs: dict, context: Context) -> dict:
return {"message": f"Hello, {inputs['name']}!"}
```
### Register and execute
```python
from apcore import Registry, Executor
registry = Registry()
registry.register("greet", GreetModule())
executor = Executor(registry=registry)
result = executor.call("greet", {"name": "Alice"})
# {"message": "Hello, Alice!"}
```
### Add middleware
```python
from apcore import LoggingMiddleware, TracingMiddleware
executor.use(LoggingMiddleware())
executor.use(TracingMiddleware())
```
### Access control
```python
from apcore import ACL, ACLRule
acl = ACL(rules=[
ACLRule(callers=["admin.*"], targets=["*"], effect="allow", description="Admins can call anything"),
ACLRule(callers=["*"], targets=["admin.*"], effect="deny", description="Others cannot call admin modules"),
])
executor = Executor(registry=registry, acl=acl)
```
## Project Structure
```
src/apcore/
__init__.py # Public API
context.py # Execution context & identity
executor.py # Core execution engine
decorator.py # @module decorator
bindings.py # YAML binding loader
config.py # Configuration
acl.py # Access control
errors.py # Error hierarchy
module.py # Module annotations & metadata
middleware/ # Middleware system
observability/ # Tracing, metrics, logging
registry/ # Module discovery & registration
schema/ # Schema loading, validation, export
utils/ # Utilities
```
## Development
### Run tests
```bash
pytest
```
### Run tests with coverage
```bash
pytest --cov=src/apcore --cov-report=html
```
### Lint and format
```bash
ruff check --fix src/ tests/
ruff format src/ tests/
```
### Type check
```bash
mypy src/ tests/
```
## 📄 License
Apache-2.0
## 🔗 Links
- **Documentation**: [docs/apcore](https://github.com/aipartnerup/apcore) - Complete documentation
- **Website**: [aipartnerup.com](https://aipartnerup.com)
- **GitHub**: [aipartnerup/apcore](https://github.com/aipartnerup/apcore)
- **PyPI**: [apcore](https://pypi.org/project/apcore/)
- **Issues**: [GitHub Issues](https://github.com/aipartnerup/apcore/issues)
- **Discussions**: [GitHub Discussions](https://github.com/aipartnerup/apcore/discussions)
| text/markdown | null | aipartnerup <tercel.yi@gmail.com> | null | null | Apache-2.0 | ai, task-orchestration, schema-driven, llm, framework, pydantic | [
"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",
"Topic :: Software Development :: Libraries :: Application Frameworks",
"Typing :: Typed"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"pydantic>=2.0",
"pyyaml>=6.0",
"pluggy>=1.0",
"pytest>=7.0; extra == \"dev\"",
"pytest-asyncio>=0.21; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"mypy>=1.0; extra == \"dev\"",
"apdev[dev]>=0.1.6; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://aipartnerup.com",
"Documentation, https://github.com/aipartnerup/apcore",
"Repository, https://github.com/aipartnerup/apcore",
"Issues, https://github.com/aipartnerup/apcore/issues",
"Changelog, https://github.com/aipartnerup/apcore/blob/main/CHANGELOG.md"
] | twine/6.2.0 CPython/3.12.10 | 2026-02-20T14:21:01.860027 | apcore-0.4.0.tar.gz | 80,737 | 6f/0c/6d057d9d2950ff86433e5e908f7bf28f45ca4022c25e9f7f24c521ee12c0/apcore-0.4.0.tar.gz | source | sdist | null | false | fa7d0a5f576989f37a79466beadde1b9 | bbf4d8c5dca3d486f8111949e6d1f8013bc53653f711f655153fec77b9cb7790 | 6f0c6d057d9d2950ff86433e5e908f7bf28f45ca4022c25e9f7f24c521ee12c0 | null | [] | 196 |
2.1 | dbt-jobs-as-code | 1.15.0 | A CLI to allow defining dbt Cloud jobs as code | # dbt-jobs-as-code
`dbt-jobs-as-code` is a tool built to handle dbt Cloud Jobs as well-defined YAML files.
> [!NOTE]
> The documentation is moving to [its dedicated website](https://dbt-labs.github.io/dbt-jobs-as-code/latest/).
It offers some advanced configuration options, like some templating capability to use the same YAML file to update different dbt Cloud projects and/or environments (see [templating](#templating-jobs-yaml-file)).
A given dbt Cloud project can use both jobs-as-code and jobs-as-ui at the same time, without any conflict.
The way we differentiate jobs defined from code from the ones defined from the UI is that the code ones have a name ending with `[[<identifier>]]`.
⚠️ Important: If you plan to use this tool but have existing jobs ending with `[[...]]` you should rename them before running any command.
Below is a demonstration of how to use dbt-jobs-as-code as part of CI/CD, leveraging the new templating features.
[!<img src="screenshot.png" width="600">](https://www.loom.com/share/7c263c560d2044cea9fc82ac8ec125ea?sid=4c2fe693-0aa5-4021-9e94-69d826f3eac5)
## Why not Terraform
Terrraform is widely used to manage infrastructure as code. And a comprehensive [Terraform provider](https://registry.terraform.io/providers/dbt-labs/dbtcloud/latest) exists for dbt Cloud, able to manage dbt Cloud jobs (as well as most of the rest of the dbt Cloud configuration like projects, environments, warehouse connections etc...).
Terraform is much more powerful but using it requires some knowledge about the tool and requires managing/storing/sharing a state file, containing information about the state of the application.
With this package's approach, people don't need to learn another tool and can configure dbt Cloud using YAML, a language used across the dbt ecosystem:
- **no state file required**: the link between the YAML jobs and the dbt Cloud jobs is stored in the jobs name, in the `[[<identifier>]]` part
- **YAML**: dbt users are familiar with YAML and we created a JSON schema allowing people to verify that their YAML files are correct
- by using filters like `--project-id`, `--environment-id` or `--limit-projects-envs-to-yml` people can limit the projects and environments checked by the tool, which can be used to "promote" jobs between different dbt Cloud environments
### But why not both `dbt-jobs-as-code` and Terraform?
But more than being exclusive from each other, dbt-jobs-as-code and Terraform can be used together:
- with `dbt-jobs-as-code` being used to manage the day to day jobs (handled by the data team)
- and Terraform being used to manage the rest of the dbt Cloud configuration and even CI and merge jobs (handled by the platform or central team)
## Usage
### Installation
#### With uv (recommended)
We recommend using `uv`/`uvx` to run the package.
If you don't have `uv` installed, you can install `uv` and `uvx`, [following the instructions on the official website](https://docs.astral.sh/uv/getting-started/installation/).
- to run the latest version of the tool: `uvx dbt-jobs-as-code`
- to run a specific version of the tool: `uvx dbt-jobs-as-code@0.9.0`
- to install the tool as a dedicated CLI: `uv tool install dbt-jobs-as-code`
- to upgrade the tool installed as a dedicated CLI: `uv tool upgrade dbt-jobs-as-code`
#### With pip
You can also use `pip` if you prefer, but we then recommend installing the tool in its own Python virtual environment. Once in a venv, install the tool with `pip install dbt-jobs-as-code` and then run `dbt-jobs-as-code ...`
### Pre-requisites
The following environment variables are used to run the code:
- `DBT_API_KEY`: [Mandatory] The dbt Cloud API key to interact with dbt Cloud. Can be a Service Token (preferred, would require the "job admin" scope) or the API token of a given user
- `DBT_BASE_URL`: [Optional] By default, the tool queries `https://cloud.getdbt.com`, if your dbt Cloud instance is hosted on another domain, define it in this env variable (e.g. `https://emea.dbt.com`)
### Commands
The CLI comes with a few different commands
#### `validate`
Command: `dbt-jobs-as-code validate <config_file_or_pattern.yml>`
Validates that the YAML file has the correct structure
- it is possible to run the validation offline, without doing any API call
- or online using `--online`, in order to check that the different IDs provided are correct
- it supports templating the jobs YAML file (see [templating](#templating-jobs-yaml-file))
#### `plan`
Command: `dbt-jobs-as-code plan <config_file_or_pattern.yml>`
Returns the list of actions create/update/delete that are required to have dbt Cloud reflecting the configuration file
- this command doesn't modify the dbt Cloud jobs
- this command can be restricted to specific projects and environments
- it accepts a list of project IDs or environments IDs to limit the command for: `dbt-jobs-as-code plan <config_file_or_pattern.yml> -p 1234 -p 2345 -e 4567 -e 5678`
- it is possible to limit for specific projects and/or specific environments
- when both projects and environments are provided, the command will run for the jobs that are both part of the environment ID(s) and the project ID(s) provided
- or it accepts the flag `--limit-projects-envs-to-yml` to only check jobs that are in the projects and environments listed in the jobs YAML file
- it supports templating the jobs YAML file (see [templating](#templating-jobs-yaml-file))
#### `sync`
Command: `dbt-jobs-as-code sync <config_file_or_pattern.yml>`
Create/update/delete jobs and env vars overwrites in jobs to align dbt Cloud with the configuration file
- ⚠️ this command will modify your dbt Cloud jobs if the current configuration is different from the YAML file
- this command can be restricted to specific projects and environments
- it accepts a list of project IDs or environments IDs to limit the command for: `dbt-jobs-as-code sync <config_file_or_pattern.yml> -p 1234 -p 2345 -e 4567 -e 5678`
- it is possible to limit for specific projects and/or specific environments
environment ID(s) and the project ID(s) provided
- or it accepts the flag `--limit-projects-envs-to-yml` to only check jobs that are in the projects and environments listed in the jobs YAML file
- it supports templating the jobs YAML file (see [templating](#templating-jobs-yaml-file))
#### `import-jobs`
Command: `dbt-jobs-as-code import-jobs --config <config_file_or_pattern.yml>` or `dbt-jobs-as-code import-jobs --account-id <account-id>`
Queries dbt Cloud and provide the YAML definition for those jobs. It includes the env var overwrite at the job level if some have been defined
- it is possible to restrict the list of dbt Cloud Job IDs by adding `... -j 101 -j 123 -j 234`
- this command also accepts a list of project IDs or environments IDs to limit the command for: `dbt-jobs-as-code sync <config_file_or_pattern.yml> -p 1234 -p 2345 -e 4567 -e 5678`
- this command accepts a `--include-linked-id` parameter to allow linking the jobs in the YAML to existing jobs in dbt Cloud, by renaming those
- once the YAML has been retrieved, it is possible to copy/paste it in a local YAML file to create/update the local jobs definition.
Once the configuration is imported, it is possible to "link" existing jobs by using the `link` command explained below.
#### `link`
Command: `dbt-jobs-as-code link <config_file_or_pattern.yml>`
Links dbt Cloud jobs with the corresponding identifier from the YAML file by renaming the jobs, adding the `[[ ... ]]` part in the job name.
To do so, the program looks at the YAML file for the config `linked_id`.
`linked_id` can be added manually or can be added automatically when calling `dbt-jobs-as-code import-jobs` with the `--include-linked-id` parameter.
Accepts a `--dry-run` flag to see what jobs would be changed, without actually changing them.
#### `unlink`
Command: `dbt-jobs-as-code unlink --config <config_file_or_pattern.yml>` or `dbt-jobs-as-code unlink --account-id <account-id>`
Unlinking jobs removes the `[[ ... ]]` part of the job name in dbt Cloud.
⚠️ This can't be rolled back by the tool. Doing a `unlink` followed by a `sync` will create new instances of the jobs, with the `[[<identifier>]]` part
- it is possible to restrict the list of jobs to unlink by adding the job identifiers to unlink `... -i import_1 -i my_job_2`
#### `deactivate-jobs`
Command: `dbt-jobs-as-code deactivate-jobs --account-id 1234 --job-id 12 --job-id 34 --job-id 56`
This command can be used to deactivate both the schedule and the CI triggers for dbt Cloud jobs. This can be useful when moving jobs from one project to another. When the new jobs have been created, this command can be used to deactivate the jobs from the old project.
### Job Configuration YAML Schema
The file `src/dbt_jobs_as_code/schemas/load_job_schema.json` is a JSON Schema file that can be used to verify that the YAML config files syntax is correct and to provide completion suggestions for the different fields supported.
To use it in VSCode, install [the extension `YAML`](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-yaml) and add the following line at the top of your YAML config file (change the path if need be):
```yaml
# yaml-language-server: $schema=https://raw.githubusercontent.com/dbt-labs/dbt-jobs-as-code/main/src/dbt_jobs_as_code/schemas/load_job_schema.json
```
### Templating jobs YAML file
`validate`, `sync` and `plan` support templating the YML jobs file since version 0.6.0
To do so:
- update the jobs YAML file by setting some values as Jinja variables
- e.g `project_id: {{ project_id }}` or `environment_id: {{ environment_id }}`
- and add the parameter `--vars-yml` (or `-v`) pointing to a YAML file containing values for your variables
The file called in `--vars-yml` needs to be a valid YAML file like the following:
```yml
project_id: 123
environment_id: 456
```
There are some example of files under `example_jobs_file/jobs_templated...`. Those examples also show how we can use Jinja logic to set some parameters based on our variables.
When using templates, you might also want to use the flag `--limit-projects-envs-to-yml`. This flag will make sure that only the projects and environments of the rendered YAML files will be checked to see what jobs to create/delete/update.
Templating also allows people to version control those YAML files and to have different files for different development layers, like:
- `dbt-jobs-as-code jobs.yml --vars-yml vars_qa.yml --limit-projects-envs-to-yml` for QA
- `dbt-jobs-as-code jobs.yml --vars-yml vars_prod.yml --limit-projects-envs-to-yml` for Prod
The tool will raise errors if:
- the jobs YAML file provided contains Jinja variables but `--vars-yml` is not provided
- the jobs YAML file provided contains Jinja variables that are not listed in the `--vars-yml` file
### Summary of parameters
| Command | `--project-id` / `-p` | `--environment-id` / `-e` | `--limit-projects-envs-to-yml` / `-l` | `--vars-yml` / `-v` | `--online` | `--job-id` / `-j` | `--identifier` / `-i` | `--dry-run` | `--include-linked-id` |
| --------------- | :-------------------: | :-----------------------: | :-----------------------------------: | :-----------------: | :--------: | :---------------: | :-------------------: | :---------: | :-------------------: |
| plan | ✅ | ✅ | ✅ | ✅ | | | | | |
| sync | ✅ | ✅ | ✅ | ✅ | | | | | |
| validate | | | | ✅ | ✅ | | | | |
| import-jobs | ✅ | ✅ | | | | ✅ | | | ✅ |
| link | | | | | | | | ✅ | |
| unlink | | | | | | | ✅ | ✅ | |
| deactivate-jobs | | | | | | ✅ | | | |
As a reminder using `--project-id` and/or `--environment-id` is not compatible with using `--limit-projects-envs-to-yml`.
We can only restricts by providing the IDs or by forcing to restrict on the environments and projects in the YML file.
## Running the tool as part of CI/CD
An example of GitHub Action is provided in the [example_cicd folder](https://github.com/dbt-labs/dbt-jobs-as-code/blob/HEAD/example_cicd). This example requires having set the GitHub secret `DBT_API_KEY`.
You can copy/paste thie file in your own repo under `.github/workflows`. The current script except your jobs `yml` file to be saved under `jobs/jobs.yml`
After a PR on `main` is approved, the action will run a `sync` to compare the local `yml` file with the dbt Cloud configuration and will create/update/delete dbt Cloud jobs to align the two.
## Reporting bugs and contributing code
- Want to report a bug or request a feature? Let us know by opening [an issue](https://github.com/dbt-labs/dbt-jobs-as-code/issues/new)
- Want to help us build dbt? Check out the [Contributing Guide](https://github.com/dbt-labs/dbt-jobs-as-code/blob/HEAD/CONTRIBUTING.md)
| text/markdown | null | dbt Labs <info@dbtlabs.com> | null | null | Apache License 2.0 | dbt, dbt Cloud | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"click<9.0.0,>=8.1.3",
"requests<3.0.0,>=2.32.0",
"loguru<1.0.0,>=0.6.0",
"deepdiff<9.0.0,>=8.6.1",
"pydantic<3.0.0,>=2.12.0",
"croniter<2.0.0,>=1.3.8",
"ruamel-yaml<1.0.0,>=0.17.21",
"rich>=12.6.0",
"PyYAML<7.0.0,>=6.0.1",
"python-dateutil<3.0,>=2.9",
"beartype<1.0.0,>=0.18.5",
"jinja2<4.0.0,>=3.1.5",
"importlib-metadata<7,>=6.0"
] | [] | [] | [] | [
"repository, https://github.com/dbt-labs/dbt-jobs-as-code.git"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:20:54.609082 | dbt_jobs_as_code-1.15.0.tar.gz | 53,979 | c6/bc/feb432573eddb6eb7b63ca87407d9dbcf7309624590c464f32ed172b0d30/dbt_jobs_as_code-1.15.0.tar.gz | source | sdist | null | false | 431de8494d74c5346013f0b2176736d8 | 48149a281a6ccff82c53ee9a1ad800ecac4e81e6280ed749ba1d675745e26f1a | c6bcfeb432573eddb6eb7b63ca87407d9dbcf7309624590c464f32ed172b0d30 | null | [] | 517 |
2.4 | naeural-core | 7.7.258 | Ratio1 Core is the backbone of the Ratio1 Edge Protocol. | # Ratio1 Core Packages (formerly Ratio1 Edge Protocol Core Modules)
Welcome to the **Ratio1 Core packages** repository, previously known as the **Ratio1 Edge Protocol Core Modules**. These core packages are the foundational elements of the Ratio1 ecosystem, designed to enhance the protocol and drive the development of the Ratio1 Edge Node through ongoing research and community contributions. This README provides an overview of the core functionalities, components, and guidance on how to integrate the Ratio1 Core Packages into your projects.
## Overview
The **Ratio1 Core packages** are engineered to facilitate the rapid advancement and deployment of AI applications at the edge within the Ratio1 ecosystem. These core modules underpin several key functionalities essential for building robust edge computing solutions and enhancing the overall protocol:
- **Data Collection**: Acquire data through various methods, including:
- **Default Plugins**: MQTT, RTSP, CSV, ODBC
- **Custom-Built Plugins**: Integration with sensors and other specialized data sources
- **Data Processing**: Transform and process collected data to prepare it for trustless model training and inference, ensuring data integrity and reliability.
- **Model Training and Inference**: Utilize plugins to train AI models and perform trustless inference tasks, leveraging decentralized resources for enhanced performance and security.
- **Post-Inference Business Logic**: Execute business logic after inference to derive actionable insights and make informed decisions based on AI outputs.
- **Pipeline Persistence**: Maintain the persistence of pipelines to ensure reliability and reproducibility of AI workflows across deployments.
- **Communication**: Enable seamless communication through both MQ-based and API-based methods, including advanced routing and load balancing via ngrok for optimized network performance.
These modules serve as the core for implementing edge nodes within the Ratio1 ecosystem or integrating seamlessly into third-party Web2 applications, providing flexibility and scalability for diverse use cases. The primary objective of the Ratio1 Core Packages is to enhance the protocol and ecosystem, thereby improving the functionality and performance of the Ratio1 Edge Node through dedicated research and community-driven contributions.
## Features
- **Modular Design**: Easily extend functionality with custom plugins for data collection, processing, and more, allowing for tailored solutions to meet specific application needs.
- **Scalability**: Designed to scale from small edge devices to large-scale deployments, ensuring consistent performance regardless of deployment size.
- **Interoperability**: Compatible with a wide range of data sources and communication protocols, facilitating integration with existing systems and technologies.
- **Ease of Integration**: The core packages are intended to be integrated as components within the Ratio1 Edge Node or third-party edge node execution engines, rather than standalone applications.
## Contributing
We welcome contributions from the community to help enhance the Ratio1 Core Packages. Your contributions play a vital role in advancing the Ratio1 ecosystem and improving the Ratio1 Edge Node.
## Installation
The Ratio1 Core Packages are not intended for standalone use. Instead, they are designed to be integrated as components within the Ratio1 Edge Node or utilized by third-party edge node execution engines. For detailed integration instructions, please refer to the documentation provided within the Ratio1 Edge Node repository or contact our support team for assistance.
## License
This project is licensed under the **Apache 2.0 License**. For more details, please refer to the [LICENSE](LICENSE) file.
## Contact
For more information, visit our website at [https://ratio1.ai](https://ratio1.ai) or reach out to us via email at [support@ratio1.ai](mailto:support@ratio1.ai).
## Project Financing Disclaimer
This project incorporates open-source components developed with the support of financing grants **SMIS 143488** and **SMIS 156084**, provided by the Romanian Competitiveness Operational Programme. We extend our sincere gratitude for this support, which has been instrumental in advancing our work and enabling us to share these resources with the community.
The content and information within this repository are solely the responsibility of the authors and do not necessarily reflect the views of the funding agencies. The grants have specifically supported certain aspects of this open-source project, facilitating broader dissemination and collaborative development.
For any inquiries regarding the funding and its impact on this project, please contact the authors directly.
## Citation
If you use the Ratio1 Core Packages in your research or projects, please cite them as follows:
```bibtex
@misc{Ratio1CorePackages,
author = {Ratio1.AI},
title = {Ratio1 Core Packages},
year = {2024-2025},
howpublished = {\url{https://github.com/Ratio1/naeural_core}},
}
```
| text/markdown | null | Andrei Ionut Damian <andrei.damian@me.com>, Cristan Bleotiu <cristibleotiu@gmail.com> | null | null | null | null | [
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"bs4",
"cryptography==42.0.7",
"decentra-vision",
"decord",
"dropbox",
"fastapi",
"gql",
"h5py",
"minio",
"opencv-python-headless",
"paho-mqtt>=1.6",
"pandas",
"pika>=1.3",
"pyarrow>=15",
"pydantic",
"pymssql",
"pynvml>=11.4",
"pyyaml>=6.0",
"ratio1>=1.0.0",
"scikit-image",
"scikit-learn",
"seaborn",
"sentencepiece",
"shapely",
"tokenizers>=0.14.1",
"torch",
"torchaudio",
"torchvision",
"transformers>=4.38.0",
"unidecode",
"uvicorn",
"web3"
] | [] | [] | [] | [
"Homepage, https://github.com/Ratio1/naeural_core",
"Bug Tracker, https://github.com/Ratio1/naeural_core/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:20:31.855368 | naeural_core-7.7.258.tar.gz | 23,867,720 | f3/79/0139f1983b218d23b835338d64a2c34e0fc7e10d3e39ff4b1cd203f8140e/naeural_core-7.7.258.tar.gz | source | sdist | null | false | d44255044049bb85f8d6fd55ffd3399a | c873634011c31efabacc0fed19f6440685bd87981aa8f3b7cb1066b2c813e5fc | f3790139f1983b218d23b835338d64a2c34e0fc7e10d3e39ff4b1cd203f8140e | null | [
"LICENSE"
] | 236 |
2.4 | amrita | 1.1.2 | A powerful AI bot framework powered by NoneBot2 | # PROJ.Amrita 🌸 - 基于 NoneBot 与 AmritaCore 的 Agent Bot
<p align= "center">
<img src="./logo/Amrita-nobg.png" width=400 height=400>
</p>
<p align="center">
<img src="https://img.shields.io/badge/Python-3.10+-blue?logo=python" alt="Python">
<img src="https://img.shields.io/badge/License-GPL--3.0-orange" alt="License">
<img src="https://img.shields.io/badge/NoneBot-2.0+-red?logo=nonebot" alt="NoneBot">
</p>
Amrita 是一个基于[NoneBot2](https://nonebot.dev/)与[AmritaCore](https://amrita-core.suggar.top)的强大聊天机器人框架，专为快速构建和部署智能聊天机器人而设计。它是一个完整的 LLM 聊天机器人解决方案，具有强大的功能和灵活性。
## 🌟 特性亮点
- **多模型支持**: 支持 OpenAI、DeepSeek、Gemini 等多种大语言模型
- **多模态能力**: 支持处理图像等多媒体内容
- **灵活适配**: 原生支持 Onebot-V11 协议，轻松对接 QQ 等平台
- **智能会话管理**: 内置会话控制和历史记录管理
- **插件化架构**: 模块化设计，易于扩展和定制
- **开箱即用**: 预设丰富的回复模板和功能配置
- **强大 CLI 工具**: 一体化命令行管理工具，简化开发和部署流程
- **Agent**: 支持智能对话管理，自动生成回复
- **智能上下文管理**: 支持智能上下文管理
- **Web UI**: 集成 Web UI，提供可视化管理界面
- **MCP**: 支持Model Context Protocol
## 📚 文档和资源
- [官方文档](https://amrita.suggar.top)
- [Core开发文档](https://amrita-core.suggar.top)
- [问题反馈](https://github.com/LiteSuggarDEV/Amrita/issues)
## 🤝 贡献
欢迎提交 Issue 和 Pull Request 来帮助改进 Amrita！
见[贡献指南](CONTRIBUTING.md)
## 📄 许可证
本项目采用 AGPL-3.0 许可证，详见[LICENSE](LICENSE)文件。
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"tomli>=2.0.0",
"tomli-w>=1.0.0",
"click>=8.2.1",
"colorama>=0.4",
"toml>=0.10.2",
"pip>=25.2",
"nonebot-plugin-localstore>=0.7.4",
"typing-extensions>=4.6.0",
"uv>=0.8.12",
"requests>=2.0",
"python-multipart>=0.0.20",
"aiofiles>=24.1.0",
"packaging>=25.0",
"zipp>=3.23.0",
"pytz>=2025.2",
"tomlkit>=0.13.3",
"nonebot-plugin-orm>=0.8.3",
"nb-cli==1.6.0",
"watchfiles>=1.1.1",
"amrita-core>=0.4.5; extra == \"full\"",
"nonebot-plugin-uniconf>=0.1.3; extra == \"full\"",
"aiomysql>=0.3.2; extra == \"full\"",
"aiopg>=1.4.0; extra == \"full\"",
"aiosqlite>=0.21.0; extra == \"full\"",
"fastmcp>=2.14.1; extra == \"full\"",
"alembic==1.16.4; extra == \"full\"",
"aiohttp>=3.13.2; extra == \"full\"",
"pillow>=12.0.0; extra == \"full\"",
"fastmcp>=2.13.0.2; extra == \"full\"",
"bcrypt>=4.3.0; extra == \"full\"",
"async-lru>=2.0.5; extra == \"full\"",
"jinja2>=3.1.6; extra == \"full\"",
"uvicorn>=0.35.0; extra == \"full\"",
"psutil>=7.0.0; extra == \"full\"",
"pytz>=2025.1; extra == \"full\"",
"stubs>=1.0.0; extra == \"full\"",
"dotenv>=0.9.9; extra == \"full\"",
"importlib>=1.0.4; extra == \"full\"",
"openai>=2.16.0; extra == \"full\"",
"pydantic>=2.4.2; extra == \"full\"",
"jieba>=0.42.1; extra == \"full\"",
"nonebot-plugin-orm>=0.8.2; extra == \"full\"",
"nonebot-adapter-onebot>=2.4.6; extra == \"full\"",
"nonebot2[fastapi]>=2.4.3; extra == \"full\""
] | [] | [] | [] | [
"Homepage, https://github.com/LiteSuggarDEV/Amrita",
"Source, https://github.com/LiteSuggarDEV/Amrita",
"Issue Tracker, https://github.com/LiteSuggarDEV/Amrita/issues"
] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-20T14:20:23.370429 | amrita-1.1.2-py3-none-any.whl | 1,088,710 | 95/5e/79ed6527541a934bdd1bf73109f7bdbacb47b78e1251462067841817bac8/amrita-1.1.2-py3-none-any.whl | py3 | bdist_wheel | null | false | 238fd61e5c3612d31f72680724a7a74e | 8b04a3cb37d8666d9b625ce0e31e546c14b424ce4160a788234bb8acab18fe0d | 955e79ed6527541a934bdd1bf73109f7bdbacb47b78e1251462067841817bac8 | GPL-3.0-or-later | [
"LICENSE"
] | 198 |
2.4 | vbelt | 0.9.1 | The VASP user's tool belt. | # vbelt
## About
vbelt is a library and a collection of scripts to manipulate VASP output files.
## Script
Available scripts:
- `chgsum`: combine two CHGCAR
- `chgx`: extract channels from CHGCAR
- `ckconv`: check a single-point computation converged
- `ckend`: check the computation ended normally
- `ckforces`: check the forces are converged in an optimization calculation
- `ckcoherence`: check a series of criterions to check that the computation is sane
- `jobtool`: precompute and predict some infos on a job
- `poscartool`: manipulate POSCAR files
- `termdos`: plot a DoS in terminal (WIP)
Run the scripts with `--help` to check for subcommands and options.
## Modules
Available modules:
- `charge_utils`: read and manipulate CHGCAR
- `forces`: extract forces from OUTCAR
- `gencalc`: facilities to generate input files
- `incar`: parse INCAR
- `jobtool`: facilities to predict some job characteristics
- `outcar`: parse some informations from OUTCAR
- `poscar`: read and write POSCAR
- `potcar`: parse some informations from POTCAR
## Installation
Most features only requires numpy, however `gencalc` also requires tc-pysh, chevron and ase.
To install all the optional dependencies use `pip install vbelt[gencalc]`.
For a minimal installation `pip install vbelt`.
| text/markdown | null | Théo Cavignac <theo.cavignac@gmail.com> | null | null | null | null | [
"Environment :: Console",
"Programming Language :: Python :: 3.7"
] | [] | null | null | null | [] | [] | [] | [
"numpy>=1.16",
"ase>=3.22; extra == \"gencalc\"",
"chevron>=0.14.0; extra == \"gencalc\"",
"tc-pysh>=0.2.0; extra == \"gencalc\"",
"pymatgen; extra == \"symmetry\""
] | [] | [] | [] | [
"Homepage, https://git.sr.ht/~lattay/vbelt"
] | Hatch/1.16.3 cpython/3.14.3 HTTPX/0.28.1 | 2026-02-20T14:19:51.831448 | vbelt-0.9.1.tar.gz | 42,882 | 36/cd/694383ad997720e7947691831164550238023c35bff5c30087a78ce4bbd1/vbelt-0.9.1.tar.gz | source | sdist | null | false | 83a017dc33129bdd9019bcbe7e505dea | af0b9ebbf4e143d8c63e7c8280709dd5d583e7c4129402ab7a7b5b8c62a13849 | 36cd694383ad997720e7947691831164550238023c35bff5c30087a78ce4bbd1 | EUPL-1.2 | [
"LICENSE"
] | 188 |
2.1 | knot-recognition | 0.1.0 | Knot recognition and Gauss/PD extraction from images. | # Knot Recognition
## Abstract
This project provides a scientific pipeline for knot recognition from images. It combines a ResNet-based CNN classifier with a structured, heuristic Gauss/PD extractor operating on skeletonized drawings. The repository is organized to support reproducible experiments, clear documentation, and future extensions.
## Installation
```bash
pip install knot-recognition
```
## Quickstart
```bash
knot --image /path/to/image.png --checkpoint ./checkpoints/best.pth --mapping mapping_example.csv
```
Optional symmetry-invariant feature extraction:
```bash
knot --image /path/to/image.png --checkpoint ./checkpoints/best.pth --mapping mapping_example.csv --features
```
Force a device:
```bash
knot --image /path/to/image.png --checkpoint ./checkpoints/best.pth --device cpu
```
```bash
knot-moves --image /path/to/image.png --overlay results/figures/moves_overlay.png
```
Diagram reducer + classifier (solver):
```bash
knot-solve --image /path/to/image.png --checkpoint ./checkpoints/best.pth --mapping mapping_example.csv
```
Training:
```bash
python -m knot_recognition.train --data-dir /path/to/data --outdir ./checkpoints --epochs 20 --batch 32 --lr 1e-3
```
Training on a specific device:
```bash
python -m knot_recognition.train --data-dir /path/to/data --device cuda
```
## Protein Knot Pipeline (Stages 1–4)
Stage 1: Extract Cα backbones (KnotProt chains):
```bash
PYTHONPATH=./src python scripts/extract_knotprot_stage1.py \
--pdb-dir data/knotprot/pdb \
--out data/knotprot/backbones.npz \
--manifest data/knotprot/backbones.csv
```
Stage 2: Projection + crossing detection
- `sample_viewpoints`, `project_polyline`, `detect_crossings`
Stage 3: Gauss code from crossings
- `gauss_code_from_crossings`
Stage 4: Hybrid ML classifier (projection image + Gauss embedding):
```bash
PYTHONPATH=./src python scripts/build_knotprot_hybrid_dataset.py \
--viewpoints 32 --limit 20 --offset 0 --stride 3 --max-points 300 \
--out data/knotprot/hybrid_dataset_part1.npz \
--manifest data/knotprot/hybrid_manifest_part1.csv
PYTHONPATH=./src python scripts/merge_hybrid_parts.py \
--out data/knotprot/hybrid_dataset.npz
python scripts/train_hybrid_classifier.py \
--data data/knotprot/hybrid_dataset.npz \
--out checkpoints/hybrid_classifier.pth \
--epochs 2 --batch 64 --lr 1e-3
```
## Project Structure
- `src/knot_recognition/`: Core Python package (models, dataset, preprocessing, inference, Gauss/PD extraction).
- `docs/`: Methods and reproducibility notes.
- `notebooks/`: Exploratory analysis and ablations.
- `scripts/`: Experiment drivers and automation helpers.
- `data/`: Reserved for datasets and processed artifacts.
- `results/`: Reserved for experiment outputs and figures.
- `raw_knot/`: Legacy dataset location (kept for compatibility).
- `outputs/`: Legacy outputs location (kept for compatibility).
- `tests/`: Synthetic tests for Gauss/PD extraction.
## Data Format
Folder-structured dataset:
```text
data_root/
3_1/
4_1/
```
Each subfolder is a class label and contains images.
## Methods (Summary)
`get_resnet(num_classes=1000, pretrained=True, model_name="resnet18", freeze_backbone=False)`
- Skeleton graph -> spur pruning -> junction clustering -> graph simplification
- Edge pairing at crossings -> curve traversal -> PD construction
- Entry point: `extract_gauss_code(skel, img_gray=None, cfg=None, return_debug=False)`
## Mapping CSV Schema
`mapping_example.csv`:
```text
label,pd_code,gauss_code
3_1,"PD[ [1,2],[3,4] ]","1 -2 3"
```
## Reproducibility
- Documented environment and workflow notes are in `docs/reproducibility.md`.
- Scientific documentation is in `docs/scientific.md`.
- Use a clean virtual environment and pinned versions for formal experiments.
## Tests
```bash
pytest -q
```
## Citation
See `CITATION.cff` for citation metadata.
## Usage
See `USAGE.md` for end-to-end examples.
## Known Limitations
- Chirality detection is heuristic and depends on how flips affect CNN confidence.
- Gauss/PD extractor assumes clean, high-contrast drawings.
- Over/under (sign) inference is not reliable from skeletons alone.
| text/markdown | abhyudaymishr | null | null | null | MIT License
Copyright (c) 2026 abhyudaymishr
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.
| knot theory, topology, computer vision, image recognition | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Scientific/Engineering :: Image Processing"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"torch",
"torchvision",
"numpy",
"opencv-python",
"scikit-image",
"scipy",
"pandas",
"Pillow",
"tqdm",
"matplotlib",
"networkx"
] | [] | [] | [] | [
"Homepage, https://github.com/abhyudaymishr/knot_recognition",
"Source, https://github.com/abhyudaymishr/knot_recognition",
"Issues, https://github.com/abhyudaymishr/knot_recognition/issues"
] | twine/6.2.0 CPython/3.12.2 | 2026-02-20T14:19:42.525386 | knot_recognition-0.1.0.tar.gz | 27,625 | 39/45/0276dc3e79974834c46983f6a24baf88d558d1b3f3982e2d23a54caac9ac/knot_recognition-0.1.0.tar.gz | source | sdist | null | false | 763ef94f4fc942112c49c9d088d7b14c | abd96b1de45ab94eef49fb2ce5681f5fe5c1d8bf53aa4bbf55315d167356f9b5 | 39450276dc3e79974834c46983f6a24baf88d558d1b3f3982e2d23a54caac9ac | null | [] | 207 |
2.4 | Tikorgzo | 0.5.0 | A TikTok video downloader that downloads source quality videos utilizing TikWM API. | # Tikorgzo
**Tikorgzo** is a TikTok video downloader written in Python that downloads videos in the highest available quality (4K, 2K, or 1080p), unlike other video downloaders. To obtain high quality videos, this app uses <b>[TikWM](https://www.tikwm.com/)</b> API and Playwright to obtain downloadable links, saving them to your Downloads folder organized by username. The app supports both Windows and Linux distributions.
Some of the key features include:
- Download TikTok video from command-line just by supplying the ID or video link.
- Supports multiple links to be downloaded.
- Set max number of simultaneous downloads.
- Supports link extraction from a text file.
- Customize the filename of downloaded videos.
- Use custom proxy.
- Config file support.
## Why Tikorgzo?
There are many TikTok video downloaders out there, but most of them usually download videos in 720p or 1080p quality. This is because they usually rely on the download links that is scrapable from the site itself, which is usually not the source video but a compressed version of it. You can use them if quality is not really much your concern. A very good open source example of this is [yt-dlp](https://github.com/yt-dlp/yt-dlp).
As a fan of archiving high quality videos, I researched and found that TikWM allows you to download videos in highest quality avaiable. I've been using it to archive videos but it is a bit inconvenient to copy and paste video links one by one to the website, so I decided to make this program to automate the process and make it more convenient for everyone who also face the same issue.
## Installation
### Requirements
- Windows, or any Linux distros
- Python `v3.12` or greater
- Google Chrome
- uv
### Steps
1. Install Python v3.12 or above. For Windows users, ensure `Add Python x.x to PATH` is checked.
2. Install Google Chrome from the official website. For Linux users, you can install Google Chrome with this command:
```console
curl -O https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install ./google-chrome-stable_current_amd64.deb
```
Alternatively, you can also use this command:
```console
uvx playwright install chrome
```
3. Open your command-line if you haven't already.
4. Install uv through `pip` command or via [Standalone installer](https://docs.astral.sh/uv/getting-started/installation/#standalone-installer).
```console
pip install uv
```
5. Install the latest published stable release into your system.
```console
uv tool install tikorgzo
```
Or if you want to get the latest features without having to wait for official release, choose this one instead:
```console
uv tool install git+https://github.com/Scoofszlo/Tikorgzo
```
6. For Windows users, if `warning: C:\Users\$USERNAME\.local\bin is not on your PATH...` appears, add the specified directory to your [user or system PATH](https://www.architectryan.com/2018/03/17/add-to-the-path-on-windows-10/), then reopen your command-line.
7. You can now download a TikTok video by running the following command (replace the number with your actual video ID or link):
```console
tikorgzo -l 7123456789109876543
```
8. After running this command, Google Chrome will open automatically. If the Cloudflare verification does not complete on its own, manually check the box.
9. Wait for the program to do it's thing. The downloaded video should appear in your Downloads folder.
## Usage
### Downloading a video
To download a TikTok video, simply put the video ID, or the video link:
```console
tikorgzo -l 7123456789109876543
```
### Downloading multiple videos
The program supports multiple video links to download. Simply separate those links by spaces:
```console
tikorgzo -l 7123456789109876543 7023456789109876544 "https://www.tiktok.com/@username/video/7123456789109876540"
```
It is recommended to enclose video links with double quotation marks to handle special characters properly.
### Downloading multiple links from a `.txt` file
Alternatively, you can also use a `.txt` file containing multiple video links and use it to download those. Ensure that each link are separated by newline.
To do this, just simply put the path to the `.txt` file.
```console
tikorgzo -f "C:\path\to\txt.file"
```
### Customizing the filename of the downloaded video
By default, downloaded videos are saved with their video ID as the filename (e.g., `1234567898765432100.mp4`). If you want to change how your files are named, you can use the `--filename-template <value>` arg, where `<value>` is your desired filename template.
Filename template is built using the following placeholders:
- **`{video_id}`** (required): The unique ID of the video.
- **`{username}`**: The TikTok username who posted the video.
- **`{date}`**: The upload date in UTC, formatted as `YYYYMMDD_HHMMSS` (for example: `20241230_235901`); or
- **`{date:<date_fmt>}`**: An alternative to `{date}` where you can customized the date in your preferred format. Working formats for `<date_fmt>` are available here: https://strftime.org/.
#### Examples
- Save as just the video ID (you don't really need to do this as this is the default naming):
```console
tikorgzo -l 1234567898765432100 --filename-template "{video_id}"
# Result: 1234567898765432100.mp4
```
- Save as username and video ID:
```console
tikorgzo -l 1234567898765432100 --filename-template "{username}-{video_id}"
# Result: myusername-1234567898765432100.mp4
```
- Save as username, date, and video ID:
```console
tikorgzo -l 1234567898765432100 --filename-template "{username}-{date}-{video_id}"
# Result: myusername-20241230_235901-1234567898765432100.mp4
```
- Save with a custom date format (e.g., `YYMMDD_HHMMSS`):
```console
tikorgzo -l 1234567898765432100 --filename-template "{username}-{date:%y%m%d_%H%M%S}-{video_id}"
# Result: myusername-241230_235901-1234567898765432100.mp4
```
Alternatively, you can also set this via config file:
```toml
[generic]
filename_template = "{username}-{date:%y%m%d_%H%M%S}-{video_id}"
```
### Changing the download directory
By default, downloaded videos are saved in the `Tikorgzo` folder inside your system's Downloads directory.
If you want to save the downloaded videos to a different directory, you can use the `--download-dir <path>` arg, where `<path>` is the path to your desired download directory:
```console
tikorgzo -l 1234567898765432100 --download-dir "C:\path\to\custom\downloads"
```
Alternatively, you can also set this via config file:
```toml
[generic]
download_dir = "C:\\path\\to\\custom\\downloads"
```
### Setting the maximum number of simultaneous downloads
When downloading many videos, the program limits downloads to 4 at a time by default.
To change the maximum number of simultaneous downloads, use the `--max-concurrent-downloads <value>` arg, where `<value>` must be in range of 1 to 16:
```console
tikorgzo -f "C:\path\to\100_video_files.txt" --max-concurrent-downloads 10
```
Alternatively, you can also set this via config file:
```toml
[generic]
max_concurrent_downloads = 10
```
### Using lazy duplicate checking
The program checks if the video you are attempting to download has already been downloaded. By default, duplicate checking is based on the 19-digit video ID in the filename. This means that even if the filenames are different, as long as both contain the same video ID, the program will detect them as duplicates.
For example, if you previously downloaded `250101-username-1234567898765432100.mp4` and now attempt to download `username-1234567898765432100.mp4`, the program will detect it as a duplicate since both filenames contain the same video ID.
If you want to change this behavior so that duplicate checking is based on filename similarity instead, use the `--lazy-duplicate-check` option. Alternatively, you can also set this via config file:
```toml
[generic]
lazy_duplicate_check = true
```
### Setting extraction delay
You can change the delay between each extraction of a download link to reduce the number of requests sent to the server and help avoid potential rate limiting or IP bans. Use the `--extraction-delay <seconds>` argument to specify the delay (in seconds) between each extraction:
```console
tikorgzo -f "C:\path\to\links.txt" --extraction-delay 2
```
Alternatively, you can set this in the config file:
```toml
[generic]
extraction_delay = 2
```
The value should be a non-negative integer or float (e.g., `2` or `0.5`).
### Choosing extractor to use
By default, this program uses `TikWMExtractor` as its extractor for grabbing high-quality download links for videos. However, you can choose `DirectExtractor` as an alternative if you prefer a faster method at the expense of potential lower resolution videos. This method directly scrapes download links from TikTok itself.
The source data used here is similar to what `yt-dlp` uses, so the highest quality available quality it shows there should be also the same here.
The downsides of this method include:
- You cannot download 4K videos.
- Certain videos will be downloaded at 720p even if a 1080p version is available.
- Certain videos may not be downloadable.
- Videos may sometimes fail to download for some reason (e.g., 403 error may appear occasionally).
To use the alternative extractor despite the downsides, use the `--extractor <value>` arg, where `<value>` is `direct`. Putting `tikwm` or not using this arg option at all will use the default extractor (`tikwm`):
```console
tikorgzo -l 1234567898765432100 --extractor direct
```
Alternatively, you can also set this in config file:
```toml
[generic]
extractor = "direct"
```
### Custom proxy
If you want to use a custom proxy for the app, you can use the `--proxy <proxy_url>` arg, where `<proxy_url>` is the URL of your desired proxy server. For example:
```console
tikorgzo -l 1234567898765432100 --proxy "255.255.255.255:8080"
```
Alternatively, you can also set this in config file:
```toml
[generic]
proxy = "255.255.255.255:8080"
```
When you use a custom proxy, the app will attempt to check if the proxy is working properly by sending a request to `https://ifconfig.me/ip` before the app uses it. If the request fails, the app will display an error message and will now exit. Otherwise, it will be used during extraction and download processes.
### Using a config file
This program can be configured via a TOML-formmatted config file so that you don't have to supply the same arguments every time you run the program.
In order to use this, create first a file named `tikorgzo.conf` in either one of these locations:
- Windows:
- `./tikorgzo.conf` (the config file in the current working directory)
- `%LocalAppData%/Tikorgzo/tikorgzo.conf`
- `%UserProfile%/Documents/Tikorgzo/tikorgzo.conf`
- Linux:
- `./tikorgzo.conf` (the config file in the current working directory)
- `~/.local/share/Tikorgzo/tikorgzo.conf`
- `~/Documents/Tikorgzo/tikorgzo.conf`
> [!IMPORTANT]
> If you have multiple config files in the above locations, the program will use the first one it finds (in the order listed above).
After that, create a table named `[generic]` and add your desired configurations in it by supplying key-value pairs, where key is the name of the config option while value is the desired value.
For example, if you want to set `max_concurrent_downloads` to `8`, enable `lazy_duplicate_check`, and set a custom `filename_template`, your config file should look like this:
```toml
[generic]
max_concurrent_downloads = 8
lazy_duplicate_check = true
filename_template = "{username}-{date:%y%m%d_%H%M%S}-{video_id}"
```
Here's an improved version with better grammar and clarity:
The key name (i.e., `max_concurrent_downloads`, `lazy_duplicate_check`, `filename_template`) that you will put here must match the command-line argument name shown when you run `tikorgzo` in the CLI, but with underscores (`_`) instead of hyphens (`-`) and without the leading double dash. For example, `--download-dir` becomes `download_dir`, `--extraction-delay` becomes `extraction_delay`, and so on.
Take note that string values must be enclosed in double quotes (`"`), while boolean and integer values must not. Moreover, boolean values must be either `true` or `false` (all lowercase).
If you wish to temporarily disable a configuration option without deleting it, you can comment out lines in the config file by adding a hash (`#`) at the beginning of the line:
```toml
[generic]
# max_concurrent_downloads = 4
# lazy_duplicate_check = true
# filename_template = "{username}-{date:%y%m%d_%H%M%S}-{video_id}"
```
> [!IMPORTANT]
> Command-line arguments will always take precedence over config file settings.
> For example, if you set `max_concurrent_downloads` to `4` in the config file but specify `--max-concurrent-downloads 2` in the command line, the program will use `2` as the value for this config option.
> [!WARNING]
> Special characters in string values (e.g., backslashes in Windows file paths) must be properly escaped using single backslash (`\`) to avoid parsing errors. Otherwise, the program will not start and will display an error message. For example, if you are using the `--download-dir` option and you have a custom Windows path `C:\Users\%UserProfile%\A_Different_Location\Tikorgzo`, the value for this option must be written as `C:\\Users\\%UserProfile%\\A_Different_Location\\Tikorgzo`.
### Upgrading and uninstalling the app
To upgrade the app, just run `uv tool upgrade tikorgzo` and wait for uv to fetch updates from the source.
To uninstall the app, just run `uv tool uninstall tikorgzo` to remove the app. Take note that this doesn't remove the Tikorgzo folder generated in your Downloads directory, as well as your config file/s that you have created.
## Reminders
- Source/high-quality videos may not always be available, depending on the source. If not available, the downloaded videos are usually 1080p or 720p.
- The program may be a bit slow during download link extraction (Stage 2) when using the default extractor, as it runs a browser in the background to extract the actual download link.
- For this reason, the program is much more aligned to those who want to download multiple videos at once. However, you can still use it to download any number of videos you want.
- Alternative extractor can be used to speed up the extraction process, but it may not always be able to get the highest quality video. Also take note that some videos may fail to download so you have to rerun the app again.
- The program has been thoroughly tested on Windows 11 and is expected to work reliably on Windows systems. For Linux, testing was performed on a virtual machine running Linux Mint, as well as on Ubuntu through WSL so it should generally work fine on most Linux distributions, but compatibility is not guaranteed.
- Recently, TikWM has implemented strict checks on their website visitors, which has affected the way the program works. Starting `v0.3.0`, the program now requires Google Chrome to be installed on your system (not required if you are using the alternative extractor). Additionally, every time you download, a browser will open in the background, which might be a bit annoying for some, but this is the best workaround (yet) I have found so far.
## Project versioning policy
Tikorgzo uses a custom project versioning policy. Minor version is bumped for every new feature added, while patch version is bumped for bug fixes and minor changes.
Please take note that every new minor version may or may not introduce breaking changes, so be sure to check the changelog for details. This is the reason why major version is fixed to `0` for now.
## License
Tikorgzo is an open-source program licensed under the [MIT](LICENSE) license.
If you can, please contribute to this project by suggesting a feature, reporting issues, or make code contributions!
## Legal Disclaimer
The use of this software to download content without the permission may violate copyright laws or TikTok's terms of service. The author of this project is not responsible for any misuse or legal consequences arising from the use of this software. Use it at your own risk and ensure compliance with applicable laws and regulations.
This project is not affiliated, endorsed, or sponsored by TikTok or its affiliates. Use this software at your own risk.
## Acknowledgements
Special thanks to <b>[TikWM](https://www.tikwm.com/)</b> for providing free API service, which serves as a way for this program to extract high quality TikTok videos.
## Contact
For questions or concerns, feel free to contact me via the following!:
- [Gmail](mailto:scoofszlo@gmail.com) - scoofszlo@gmail.com
- Discord - @scoofszlo
- [Reddit](https://www.reddit.com/user/Scoofszlo/) - u/Scoofszlo
- [Twitter](https://twitter.com/Scoofszlo) - @Scoofszlo
| text/markdown | null | Scoofszlo <scoofszlo@gmail.com> | null | null | null | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"aiofiles>=24.1.0",
"aiohttp>=3.12.15",
"bs4>=0.0.2",
"pip>=25.1.1",
"platformdirs>=4.3.8",
"playwright>=1.54.0",
"requests>=2.32.4",
"rich>=14.0.0",
"rich-argparse>=1.7.1",
"toml>=0.10.2"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:19:19.183096 | tikorgzo-0.5.0.tar.gz | 115,069 | b7/aa/eb61c606c469c027a0c190366d3c2cca1616b7adccc02c161fcc7c3017e9/tikorgzo-0.5.0.tar.gz | source | sdist | null | false | 4151eeab2291c71d5a7dd3d672019e9e | 71d3621dc119efe6ea8af5d7903dc505eaae49bddb79a1b2793f22b735a2f1ea | b7aaeb61c606c469c027a0c190366d3c2cca1616b7adccc02c161fcc7c3017e9 | null | [
"LICENSE"
] | 0 |
2.4 | agent-lighthouse | 0.4.0 | Multi-Agent Observability SDK for Agent Lighthouse | # Agent Lighthouse SDK (Python)
The official Python client for instrumenting AI agents with Agent Lighthouse.
## Features
- **Automatic Tracing**: Decorators for agents, tools, and LLM calls.
- **Async Support**: Fully compatible with async/await workflows.
- **State Management**: Expose internal agent state (memory, context) for real-time inspection.
- **Token Tracking**: Automatically capture token usage and costs from LLM responses.
## Installation
Install from PyPI:
```bash
pip install agent-lighthouse
```
Or install from source in development mode:
```bash
cd sdk
pip install -e .
```
## Quick Start
### 1. Initialize Tracer
```python
from agent_lighthouse import LighthouseTracer
# Use your API Key (starts with lh_)
tracer = LighthouseTracer(api_key="lh_...")
```
### 2. Add Decorators
Wrap your functions with `@trace_agent`, `@trace_tool`, or `@trace_llm`.
```python
from agent_lighthouse import trace_agent, trace_tool, trace_llm
@trace_tool("Web Search")
def search_web(query):
# ... logic ...
return results
@trace_llm("GPT-4", model="gpt-4-turbo", cost_per_1k_prompt=0.01)
def call_llm(prompt):
# ... call OpenAI ...
return response
@trace_agent("Researcher")
def run_research_agent(topic):
data = search_web(topic)
summary = call_llm(f"Summarize {data}")
return summary
```
### 3. Run It
Just run your script as normal. The SDK will automatically send traces to the backend.
## State Inspection
Allow humans to inspect and modify agent state during execution:
```python
from agent_lighthouse import get_tracer
@trace_agent("Writer")
def writer_agent():
tracer = get_tracer()
# Expose state
tracer.update_state(
memory={"draft": "Initial draft..."},
context={"tone": "Professional"}
)
# ... execution continues ...
```
## Zero-Touch Auto-Instrumentation (Magic Import)
No code changes to your LLM calls. Just import once at the top of your script:
```python
import agent_lighthouse.auto # auto-instruments OpenAI, Anthropic, requests, and frameworks
```
This automatically captures:
- LLM latency
- Token usage
- Cost (best-effort pricing)
Content capture is **off by default**. Enable if you explicitly want payloads:
```bash
export LIGHTHOUSE_CAPTURE_CONTENT=true
```
## Configuration
You can configure the SDK via environment variables:
| Variable | Description | Default |
|----------|-------------|---------|
| `LIGHTHOUSE_API_KEY` | Your machine API key | `None` |
| `LIGHTHOUSE_BASE_URL` | URL of the backend API | `http://localhost:8000` |
| `LIGHTHOUSE_AUTO_INSTRUMENT` | Enable auto-instrumentation | `1` |
| `LIGHTHOUSE_CAPTURE_CONTENT` | Capture request/response payloads | `false` |
| `LIGHTHOUSE_LLM_HOSTS` | Allowlist extra LLM hosts for requests instrumentation | `""` |
| `LIGHTHOUSE_PRICING_JSON` | Pricing override JSON string | `""` |
| `LIGHTHOUSE_PRICING_PATH` | Pricing override JSON file path | `""` |
| `LIGHTHOUSE_DISABLE_FRAMEWORKS` | Disable framework adapters (csv) | `""` |
| text/markdown | null | Aditya Kumar <adityacode2112@gmail.com> | null | null | MIT | agents, multi-agent, observability, tracing, debugging | [
"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",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"httpx>=0.25.0",
"crewai>=0.1.0; extra == \"crewai\"",
"langgraph>=0.0.1; extra == \"langgraph\"",
"pytest>=8.3.0; extra == \"dev\"",
"pytest-asyncio>=0.24.0; extra == \"dev\"",
"pytest-cov>=5.0.0; extra == \"dev\"",
"ruff>=0.8.0; extra == \"dev\"",
"bandit>=1.8.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/noogler-aditya/Agent-Lighthouse",
"Documentation, https://github.com/noogler-aditya/Agent-Lighthouse#readme",
"Repository, https://github.com/noogler-aditya/Agent-Lighthouse"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-20T14:18:41.527704 | agent_lighthouse-0.4.0.tar.gz | 21,587 | b1/e3/b2937cb1a813080d465f498388397a745af60ec5f1f6b8d33e4d8df37ab0/agent_lighthouse-0.4.0.tar.gz | source | sdist | null | false | 4283febe95399f06ceb017519cd5749d | e3169252ac45a30acae264f8ca6696b52f87a79f9ae7159ea4a97c3696768ff1 | b1e3b2937cb1a813080d465f498388397a745af60ec5f1f6b8d33e4d8df37ab0 | null | [] | 207 |
2.4 | Products.urban | 2.9.11 | Urban Certificate Management | *********
iA. Urban
*********
.. topic:: Présentation
iA.Urban est un logiciel d'iMio (INTERCOMMUNALE DE MUTUALISATION INFORMATIQUE ET OPÉRATIONNELLE) qui a pour but de faciliter la gestion des dossiers d'urbanisme et d'environnement pour les pouvoirs locaux.
Il se concentre sur trois grand aspects:
1. L'encodage structuré des dossiers. Ce qui permet:
- de générer automatiquement les documents liés aux diverses procédures.
- faire des liens entre dossiers à partir de réferénces cadastrales communes.
- de retrouver un dossier facilement suivant divers critères de recherches.
2. La cartographie. Celle-ci permet(tra):
- de visualiser les différentes couches de la région wallone.
- d'intégrer les propres couches cwspécifiques à chaque pouvoir local.
- de pré-remplir les données d'un dossier en fonction des couches trouvées depuis
ses références cadastrales.
3. La gestion des dossiers au jour le jour via un échéancier qui permet en seul coup d'oeil, d'embrasser les étapes prioritaires des dossiers en cours.
* `Documentation interne <https://docs.imio.be/interne/iaurban/index.html>`_
* `Documentation client <https://docs.imio.be/iaurban/>`_
* `Code source GitHub <https://github.com/IMIO/Products.urban/>`_
* `Support iMio (en cas de problèmes) <https://support.imio.be/>`_
Changelog
=========
.. You should *NOT* be adding new change log entries to this file.
You should create a file in the news directory instead.
For helpful instructions, please see:
https://github.com/plone/plone.releaser/blob/master/ADD-A-NEWS-ITEM.rst
.. towncrier release notes start
2.9.11 (2026-02-20)
-------------------
Bug fixes:
- URB-3485 Add architect folder view
[jchandelle] (URB-3485)
- Change documentation url
[jchandelle] (URB-3531)
2.9.10 (2026-02-19)
-------------------
Bug fixes:
- Fix keydate getter in case date not found
[jchandelle] (SUP-51022)
- Fix broken eventType data introduced by a previous upgrade step
[daggelpop]
Fix and add logger in external method to fix missing event types
[jchandelle] (SUP-51053)
2.9.9 (2026-02-18)
------------------
Bug fixes:
- Add the key `pod_portal_types` in drop key in import config view
[jchandelle] (URB-3521)
2.9.8 (2026-02-17)
------------------
Bug fixes:
- Avoid an error when event title contains special char
[mpeeters] (SUP-50992)
2.9.7 (2026-02-16)
------------------
Bug fixes:
- Fix encoding in table column
[jchandelle] (URB-3484)
Internal:
- Remove unused vocabulary
[jchandelle] (URB-3520)
2.9.6 (2026-02-16)
------------------
Bug fixes:
- Fix unicode error
[jchandelle] (SUP-36370)
2.9.5 (2026-02-16)
------------------
New features:
- Add upgrade step to cook javascript resources
Handle redirect on Notice response forms
Hide portlets on Notice response forms
Condition Notice response actions' visibility on presence of notice ID on licence
Remove `noticeId` fields
[daggelpop] (URB-2524)
2.9.4 (2026-02-10)
------------------
Bug fixes:
- Fix broken release
[mpeeters] (PR-509)
- Fix history view with missing `site_url` required parameter
[jchandelle] (SUP-50324)
2.9.3 (2026-02-07)
------------------
New features:
- Show form data sent to Notice
Refactor Notice responses with forms
Add Notice folder manager (for new installations)
Expand REST API to include Notice data
Rename college decision in Notice forms
[daggelpop] (PR-509)
- Include decision in Summary Report response
[daggelpop] (URB-3311)
- Add Notice response to send documents
Add vocabulary of licence documents available to send to Notice
Refactor LicenceDocumentsVocabulary for easier subclassing
[daggelpop] (URB-3514)
- Add housing vocabulary
[jchandelle] (URBBDC-3221, URBBDC-3222, URBBDC-3271)
Bug fixes:
- Fix base class for housing and roaddecree
[jchandelle] (SUP-50162)
2.9.2 (2026-01-22)
------------------
Bug fixes:
- Fix a portlet error when notice WS url is not defined
[mpeeters] (URB-2652)
2.9.1 (2026-01-21)
------------------
Bug fixes:
- Cleanup unwanted lines that were keeped by git merge
[mpeeters] (URB-2652)
2.9.0 (2026-01-20)
------------------
New features:
- Implement Notice MVP
[ndemonte, wboudabous, mpeeters] (URB-2652)
Bug fixes:
- Add external method to fix `subdividerName` in parcellings
[jchandelle] (SUP-46704)
- Fix `get_all_rules_for_this_event` to filter on rule type
[jchandelle] (URB-3481)
2.8.0 (2026-01-18)
------------------
Bug fixes:
- Add an upgrade step to install RoadDecree type
[mpeeters]
Add check for new type install to avoid double install
[jchandelle] (URB-2658)
- Fix import config and ordering content script
[jchandelle] (URBBDC-3142)
- URBBDC-3204: Fix a performance issue with rendering of actions when `suspend_freeze` is is the transitions
[mpeeters] (URBBDC-3204)
Internal:
- Black & isort
[mpeeters] (URBBDC-3142)
- Make dependency for numpy optional before a replacement
[mpeeters] (URBBDC-3257)
2.8.0b1 (2025-10-27)
--------------------
New features:
- Activate `RoadDecree` in config.py.
[aduchene] (URB-3151)
2.8.0a5 (2025-09-23)
--------------------
New features:
- [WBoudabous]
Add translation for the buildingType field in the housing procedure.
Fix setuphandler to return the existing config folder instead of None. (URBBDC-3142)
2.8.0a4 (2025-09-22)
--------------------
New features:
- Use imio.pm.wsclient 2.x version (REST).
[aduchene]
Add `get_last_plonemeeting_date`, `get_last_college_date` and `get_last_college_date` to CODT_BaseBuildLicence.
[aduchene]
Refactor PloneMeeting WS methods to use imio.pm.wsclient 2.x version.
[aduchene] (URB-3151)
- Add building procedure's
[WBoudabous, aduchene] (URBBDC-3142)
2.8.0a3 (2025-08-27)
--------------------
New features:
- Added buildingType attribute to the housing procedure.
[WBoudabous] (URBBDC-3221)
- Added buildingPart attribute to the housing procedure.
[WBoudabous] (URBBDC-3222)
- Updated translations for workflow states in the housing procedure.
[WBoudabous] (URBBDC-3229)
2.8.0a2 (2025-08-07)
--------------------
New features:
- Added a taxation field.
[WBoudabous] (URBBDC-3223)
2.8.0a1 (2025-08-03)
--------------------
New features:
- Add translation for nonapplicable state in Division
[jchandelle] (SUP-39760)
- Added merge fields for observation and Vocabulary events.
Added merge fields for dimension.
Deactivated the "Road Decree" licence type.
[WBoudabous] (URBBDC-3218)
- Add nature of the building vocabulary.
[WBoudabous] (URBBDC-3221)
- Add part of the building vocabulary.
[WBoudabous] (URBBDC-3222)
- Remove the fields "usage", "policeTicketReference", and "referenceProsecution" from the Housing schema.
[WBoudabous] (URBBDC-3224)
- Reorder fields description, use_bound_licence_infos in the housing shema.
[WBoudabous] (URBBDC-3226)
- Updated the "inspection_context" field for the Housing procedure:
Moved it to the "urban_inspection" schemata.
Switched to a new dynamic vocabulary: "inspectioncontexts".
[WBoudabous] (URBBDC-3227)
- Update housing workflow.
[WBoudabous] (URBBDC-3229)
Bug fixes:
- Add RoadDecree to URBAN_TYPES to be able to use it in the tests.
[aduchene] (URB-3293)
Internal:
- Black
[mpeeters] (URBBDC-3142)
2.7.43 (2025-08-12)
-------------------
Bug fixes:
- Fix patrimony certificates interface
[jchandelle] (SUP-46330)
2.7.42 (2025-07-08)
-------------------
New features:
- Add option to add complementary delay to task
Add value for SPW cyberattack
[jchandelle] (URB-3337)
Bug fixes:
- Revert: Add building procedure's
[WBoudabous, aduchene] (URBBDC-3142)
2.7.41 (2025-06-18)
-------------------
New features:
- Add translation for nonapplicable state in Division
[jchandelle] (SUP-39760)
- Add building procedure's
[WBoudabous, aduchene] (URBBDC-3142)
2.7.40 (2025-06-10)
-------------------
Bug fixes:
- Revert "URB-3293 - Add RoadDecree to URBAN_TYPES (#340)"
[mpeeters] (URB-3293)
2.7.39 (2025-06-07)
-------------------
New features:
- Add way to easily hide licence type
[jchandelle] (SUP-33793)
- Change display of inquiry view
[jchandelle] (SUP-44199)
- Add a message in case we can't link pod template
[jchandelle] (SUP-44861)
Bug fixes:
- Fix history parcel view when missing capakey
[jchandelle] (SUP-36370)
- Fix filename encoding in mail sending
[jchandelle] (SUP-43946)
- Fix recipient import in inquiry event
[jchandelle] (SUP-44583)
- Fix 220 viewlet house number encoding
jchandelle (SUP-44642)
- Fix link pod template in import config
[jchandelle] (SUP-44861)
2.7.38 (2025-05-27)
-------------------
New features:
- Add debug functionality for schedule task
[mpeeters] (URB-3070)
Bug fixes:
- Add RoadDecree to URBAN_TYPES so it can be used in the tests.
[aduchene] (URB-3293)
Internal:
- Move `urban.schedule.condition.deposit_past_20days` into urban.schedule package
[mpeeters] (URB-3154)
2.7.37 (2025-04-29)
-------------------
Bug fixes:
- Fix encoding in mail send notification
[jchandelle] (SUP-43917)
2.7.36 (2025-04-24)
-------------------
Bug fixes:
- Fix logging syntax error
[jchandelle] (SUP-44123)
- Disable getProxy function behind a env var
[jchandelle] (URB-3230)
2.7.35 (2025-04-03)
-------------------
New features:
- Add environment fieldset to every licence type
Add habitation fieldset to `MiscDemand`, `PreliminaryNotice` and `ProjectMeeting`
[daggelpop] (SUP-33774)
- Add message explaining how to format CSV for inquiry
[jchandelle] (URB-2876)
- Move centrality in first position in the fieldset
[daggelpop] (URB-3017)
- Add patrimony fieldset to multiple licence types
[daggelpop] (URB-3121)
- Add stringinterp to get foldermanager email
[jchandelle] (URB-3283)
- Add button to inquiry to get neighbors address
[jchandelle] (URB-3286)
Bug fixes:
- Fix handling EnvironmentRubricTerm in import config
[jchandelle] (URB-3296)
2.7.34 (2025-03-27)
-------------------
Bug fixes:
- Fix licence type condition in content rules
[jchandelle] (SUP-43534)
2.7.33 (2025-03-27)
-------------------
Bug fixes:
- Fix event send mail notification title encoding
[jchandelle] (SUP-43533)
2.7.32 (2025-03-24)
-------------------
Bug fixes:
- Fix view for fixing task uid and add possiblity to call on licence folder
[jchandelle] (SUP-43189)
2.7.31 (2025-03-12)
-------------------
New features:
- Add possibility to get template merged when import
[jchandelle] (SUP-39711)
Bug fixes:
- Ensure 'in_progress'state covers 'complete' and 'deposit' states in statistics calculation.
[WBoudabous] (SUP-42045)
- Fix lost value in licence duplication
[jchandelle] (SUP-42578)
- Clarify `Copy to claimant`
[daggelpop] (SUP-42931)
- Add External method to fix annoncements tasks
[jchandelle] (URB-2680)
Internal:
- Fix ViewPageTemplateFile import
[jchandelle] (SUP-41619, URB-3237)
2.7.30 (2025-02-07)
-------------------
New features:
- Add utility view to fix task_config_UID on task
[jchandelle] (SUP-41619)
- Add utils view to closed task depending filter
[jchandelle] (URB-3237)
- Add reorder to event attachment
[jchandelle] (URBBDC-1111)
Bug fixes:
- Fix external decision values
[daggelpop]
Handle default vocabulary values for a non-array field
[daggelpop] (SUP-40288)
- Fix urban vocabularies following configuration order
[WBoudabous] (SUP-41929)
- Add missing translation in schedule config
[WBoudabous] (URB-3142)
2.7.29 (2025-02-04)
-------------------
Bug fixes:
- Fix encoding in error message for import csv from carto
Fix logic and pattern for import csv from carto
[jchandelle] (URB-3250)
2.7.28 (2025-02-02)
-------------------
Bug fixes:
- Fix missing indentation
[jchandelle] (URB-3250)
2.7.27 (2025-01-31)
-------------------
New features:
- Add compatibility with csv from carto to inquiry event
[jchandelle] (URB-3250)
Bug fixes:
- Fix sending zem document by mail
[jchandelle] (SUP-40979)
- Revert "URB-3151 - imio.pm.wsclient 2.x + roaddecree (classic) (#258)"
[daggelpop] (SUP-42300)
2.7.26 (2025-01-23)
-------------------
Bug fixes:
- Fix retrieval vocabulary in upgrade step
[jchandelle] (URB-2680)
2.7.25 (2025-01-21)
-------------------
Bug fixes:
- Fix upgrade step
[jchandelle] (URB-2680)
2.7.24 (2024-12-03)
-------------------
New features:
- Add merge field for rubric description
[jchandelle] (SUP-38659)
- Create new trigger for decision date reindex
[jchandelle] (URB-2366)
- Add bound licences field to patrimony certificates
[daggelpop] (URB-3046)
- Add latest new vocabulary terms for form_composition
[dmshd] (URB-3126)
- Use imio.pm.wsclient 2.x version (REST).
[aduchene]
Add `get_last_plonemeeting_date`, `get_last_college_date` and `get_last_college_date` to CODT_BaseBuildLicence.
[aduchene] (URB-3151)
- Implement `.getSecondDeposit()`
[dmshd] (URB-3152)
- Remove permission to create integrated licences
[daggelpop] (URB-3165)
Bug fixes:
- Allow corporate tenant in inspections
[daggelpop] (SUP-33621)
- Fix follup event creation in ticket
[jchandelle] (SUP-36493)
- Fix missing getLastAcknowledgment for division
[jchandelle] (SUP-37911)
- Add centrality to every licence & make it a multiselect
[daggelpop] (URB-3017)
- Add patrimony fieldset to patrimony certificate
[daggelpop]
Migrate patrimony certificates to their correct object class (instead of misc demand)
[daggelpop] (URB-3121)
2.7.23 (2024-11-15)
-------------------
Bug fixes:
- Fix frozen_suspension state
[jchandelle] (SUP-39511)
- Fix Task config
[jchandelle] (URB-2680)
- Fix existing c13 title upgrade
[daggelpop] (URB-3090)
- Fix import pod templates
[jchandelle] (URB-3190)
2.7.22 (2024-10-25)
-------------------
New features:
- Add new condition in content rules for licence type
[jchandelle] (URB-3020)
- Add banner on top of event after mail send
[jchandelle] (URB-3204)
Bug fixes:
- Fix comment retrieval in transition form
[daggelpop] (SUP-35563)
- Fix address comparison in _areSameAdresses
[dmshd] (SUP-39098)
- Fix an issue when there was too many connection open that raised a SQLAlchemy error
[laulaz] (SUP-39919)
- Fix content rules for event type
[jchandelle] (SUP-40117)
- Translate `suspension` terms in French
[daggelpop] (URB-3007)
- Fix opinion condition text
[jchandelle] (URB-3020)
- Fix missing function to have multiple inquiry on CODT commercial licence
[jchandelle] (URB-3130)
- Fix export import des config
[jchandelle] (URB-3190)
2.7.21 (2024-10-09)
-------------------
Bug fixes:
- Handle null value in `EventTypeConditionExecutor`
[daggelpop] (SUP-39901)
- Translate `suspend` in French
[daggelpop] (URB-3007)
- Update content rule title
[dmshd] (URB-3198)
2.7.19 (2024-10-04)
-------------------
Bug fixes:
- Fix getInquiryRadius method
[jchandelle] (URB-2983)
2.7.18 (2024-10-04)
-------------------
New features:
- Add translation and add contextual title to the form from send email action
[jchandelle] (URB-3020)
Bug fixes:
- Fix missing extending validity date
[jchandelle] (URB-3153)
Internal:
- Add a new field "additional reference" and configure faceteed navigation
[fngaha] (URB-2595)
- improve the functionality of searching for owners within a defined radius.
[fngaha] (URB-2983)
2.7.17 (2024-10-01)
-------------------
New features:
- Translate all untranslated & empty msgtr
While working on URB-2503 and while I was there, I took the opportunity to translate all untranslated and empty msgtr in the urban.po file. [dmshd] (URB-2503-Fill_all_untranslated_msgtr)
- Replace None occurences by "Aucun(e)"
I replaced all "None" occurences and set "Aucun(e)" as the default value for translations instead of None or "-" for improved readability / accessibility / ux.
[dmshd] · URB-2503 (URB-2503-Replace_None_by_Aucun-e)
- Improve / translate "See more..." link text
I had to translate "See more..." and decided that "Lire les textes" would be a better translation for better readability and accessibility.
The context is a link that follows "Textes du point Délib: See more...".
Now it reads "Textes du point Délib: Lire les textes".
[dmshd] · URB-2503 (URB-2503-Replace_See_more_dotdotdot_link_by_Lire_les_textes)
- Improve truncated "Voir..." link text
While I had to translate the untranslated "See more..." link. I spotted that truncated long text had "Voir..." as a link text. I replaced it with "Lire la suite" for better readability and accessibility.
[dmshd] · URB-2503 (URB-2503-Replace_Voir_plus_dotdotdot_by_Lire_la_suite)
- Add centrality to commercial licence
[daggelpop] (URB-3017)
- Add 3 surface fields to commercial licence
[daggelpop] (URB-3117)
- Add field `D.67 CoPat` to patrimony fieldset
daggelpop (URB-3167)
Bug fixes:
- Fix merge field getStreetAndNumber
[jchandelle] (SUP-38082)
- Fix mail message encoding
[jchandelle] (SUP-39227)
- Fix space causing bug
[dmshd] (URB-2676)
- Fix typo in french translation
This is a bugfix for URB-3128. "Cessastion" -> "Cessation".
[dmshd] (URB-3128-Fix_typo_in_french_translation)
- Fix event_type condition for content rules
[jchandelle] (URB-3182)
Internal:
- Set buildout cache directories.
I had a network problem and I had to rerun from the beginning. Took a long time. I searched for a way to fasten and discovered that I could set the cache directories. I set the cache directories as the iA.Delib team does it at iMio.
[dmshd] (URB-3135-define_buildout_cache_directories)
- Ignore .python-version (pyenv file) and sort lines in .gitignore file.
[dmshd] (URB-3135-ignore-python-version-file-and-sort-lines)
2.7.16 (2024-07-25)
-------------------
Bug fixes:
- Fix faceted widget id collision
[daggelpop] (URB-3090)
2.7.15 (2024-07-05)
-------------------
New features:
- Add rule action for sending mail with attachments
Add rule condition for corresponding event type and opinion to ask
Add action for sending mail from event context with document in attachement
[jchandelle] (URB-3020)
- Change limit year of date widget to current year + 25
[jchandelle] (URB-3153)
Bug fixes:
- Fix getValidityDate indexation
[jchandelle]
Fix validity filter title
[jchandelle] (URB-3090)
- Give dynamic group reader roles for obsolete licences
[daggelpop] (URB-3131)
2.7.14 (2024-06-27)
-------------------
New features:
- Adapt vocabulary default config values for 2024 CODT reform
[daggelpop] (URB-3003)
- Add frozen state
[jchandelle] (URB-3007)
- Allow linking to patrimony certificates
[daggelpop] (URB-3063)
- Add validity date filter and index
[jchandelle] (URB-3090)
- Add new terms to foldercategories vocabulary
[daggelpop] (URB-3096)
- Rename Patrimony certificate
[daggelpop] (URB-3116)
- Add `get_bound_licences` and `get_bound_patrimonies` to CODT_BaseBuildLicence
[daggelpop] (URB-3125)
Bug fixes:
- Mark PatrimonyCertificate as allowed type for bound_licences field in CODT build licences
[daggelpop] (URB-3046)
2.7.13 (2024-05-28)
-------------------
New features:
- Add external method to add back deleted licence folder
[jchandelle] (URB-3086)
Bug fixes:
- Fix unicode error on street name merge field
[fngaha] (SUP-34184)
- Avoid to display disabled vocabulary entries with no start or end validity date
[mpeeters] (SUP-36742)
- Fix error at EnvClassBordering creation
[jchandelle] (URB-3108)
2.7.12 (2024-04-25)
-------------------
Bug fixes:
- Fix wrong files export
[jchandelle] (MURBMONA-48)
2.7.11 (2024-04-25)
-------------------
Bug fixes:
- Add event sub file in export content
Add missing portal_type to export sub content
[jchandelle] (MURBMONA-48)
Internal:
- Add `withtitle` parameter to the getApplicantsSignaletic method
[fngaha] (SUP-33759)
- Improve merge fields
Provide a merge field that only returns streets
Adapt the getStreetAndNumber method field to be able to receive a separation parameter between the street and the number
[fngaha] (SUP-34184)
- Update the translation of empty fields
[fngaha] (URB-3079)
2.7.10 (2024-04-10)
-------------------
New features:
- Add view for import urban config
[jchandelle] (SUP-36419)
2.7.9 (2024-04-07)
------------------
Bug fixes:
- Avoid an error if a vocabulary term was removed
[mpeeters] (SUP-36403,SUP-36406)
- Fix logic on some methods to exclude invalid vocabulary entries
[mpeeters] (URB-3002)
Internal:
- Add tests for new vocabulary logic (start and end validity)
[mpeeters] (URB-3002)
2.7.8 (2024-04-02)
------------------
Bug fixes:
- Add `state` optional parameter to `getLastAcknowledgment` method to fix an issue with schedule start date
[mpeeters] (SUP-36274)
- Avoid an error if an advice was not defined
[mpeeters] (SUP-36276)
2.7.7 (2024-04-01)
------------------
Bug fixes:
- Fix an error in calculation of prorogated delays
[mpeeters] (URB-3008)
Internal:
- Add tests for buildlicence and CU2 completion schedule
[mpeeters] (URB-3005)
2.7.6 (2024-03-25)
------------------
Bug fixes:
- Fix an issue with upgrade step numbers
[mpeeters] (URB-3002)
2.7.5 (2024-03-24)
------------------
New features:
- Add caduc workflow state
[jchandelle] (URB-3007)
- Add `getIntentionToSubmitAmendedPlans` method for documents
[mpeeters] (URB-3008)
- Add a link field on CODT build licences
[mpeeters] (URB-3046)
Bug fixes:
- Move methods to be available for every events.
Change `is_CODT2024` to be true if there is no deposit but current date is greater than 2024-03-31.
[mpeeters] (URB-3008)
2.7.4 (2024-03-20)
------------------
Bug fixes:
- Invert Refer FD delay 30 <-> 40 days
[mpeeters] (URB-3008)
2.7.3 (2024-03-20)
------------------
New features:
- Add `is_not_CODT2024` method that can be used in templates
[mpeeters] (URB-3008)
Bug fixes:
- Fix update of vocabularies
[mpeeters] (URB-3002)
2.7.2 (2024-03-18)
------------------
New features:
- Add `getCompletenessDelay`, `getReferFDDelay` and `getFDAdviceDelay` methods that can be used in templates
[mpeeters] (URB-3008)
2.7.1 (2024-03-14)
------------------
Bug fixes:
- Fix delay vocabularies value order
[mpeeters] (URB-3003)
2.7.0 (2024-03-14)
------------------
New features:
- Add `is_CODT2024` and `getProrogationDelay` methods that can be used in template
[mpeeters] (URB-2956)
- Adapt vocabulary logic to include start and end validity dates
[mpeeters] (URB-3002)
- Adapt vocabulary terms for 2024 CODT reform
[daggelpop] (URB-3003)
- Add `urban.schedule` dependency
[mpeeters] (URB-3005)
- Add event fields `videoConferenceDate`, `validityEndDate` & marker `IIntentionToSubmitAmendedPlans`
[daggelpop] (URB-3006)
Bug fixes:
- Avoid an error if the closing state is not a valid transition
[mpeeters] (SUP-35736)
Internal:
- Provided prorogation field for environment license
[fngaha] (URB-2924)
- Update applicant mailing codes :
Replace mailed_data.getPersonTitleValue(short=True), mailed_data.name1, mailed_data.name2 by mailed_data.getSignaletic()
[fngaha] (URB-2947)
2.6.25 (2024-02-13)
-------------------
Bug fixes:
- Fix an issue with installation through collective.bigbang
[mpeeters] (URB-3016)
2.6.24 (2024-02-13)
-------------------
Bug fixes:
- Add upgrade step to reindex uid catalog
[jchandelle] (URB-3015)
2.6.23 (2024-02-09)
-------------------
Bug fixes:
- Fix reference validator for similar ref
[jchandelle] (URB-3012)
2.6.22 (2024-02-05)
-------------------
New features:
- Add index for street code
[jchandelle] (MURBFMAA-20)
2.6.21 (2023-12-26)
-------------------
New features:
- Add prosecution ref and ticket ref to Inspection
[ndemonte] (SUP-27127)
- Underline close due dates
[ndemonte] (URB-2515)
- Add stop worksite option to inspection report
[jchandelle] (URB-2827)
- Remove reference FD field from preliminary notice
[jchandelle] (URB-2831)
Bug fixes:
- Validate CSV before claimant import
[daggelpop] (SUP-33538)
- Fix an issue with Postgis `ST_MemUnion` by using `ST_Union` instead that also improve performances
[mpeeters] (SUP-34226)
- Fix integrated licence creation by using unicode for regional authorities vocabulary
[jchandelle] (URB-2869)
2.6.20 (2023-12-12)
-------------------
Bug fixes:
- Fix street number with specia character in unicode
[jchandelle] (URB-2948)
2.6.19 (2023-12-04)
-------------------
Bug fixes:
- Fix an issue with Products.ZCTextIndex that was interpreting `NOT` as token instead of a word for notary letter references
[mpeeters] (MURBARLA-25)
2.6.18 (2023-11-23)
-------------------
Bug fixes:
- Add `fix_schedule_config` external method ta fix class of condition objects
[mpeeters] (SUP-33739)
2.6.17 (2023-11-16)
-------------------
Bug fixes:
- Adapt opinion request worklflow to bypass guard check for managers
[mpeeters] (SUP-33308)
Internal:
- Provide getFirstAcknowledgment method
[fngaha] (SUP-32215)
2.6.16 (2023-11-06)
-------------------
Bug fixes:
- Fix serializer to include disable street in uid resolver
[jchandelle] (MURBMSGA-37)
- Fix street search to include disable street
[jchandelle] (URB-2696)
2.6.15 (2023-10-12)
-------------------
Internal:
- Fix tests
[mpeeters] (URB-2855)
- Improve performances for add views
[mpeeters] (URB-2903)
2.6.14 (2023-09-13)
-------------------
Bug fixes:
- Avoid an error if a vocabulary value was removed, instead log the removed value and display the key to the user
[mpeeters] (SUP-32338)
Internal:
- Reduce logging for sql queries
[mpeeters] (URB-2788)
- Fix tests
[mpeeters] (URB-2855)
2.6.13 (2023-09-05)
-------------------
Bug fixes:
- Move catalog import in urban type profile
[jchandelle] (URB-2868)
- Fix facet config xml
[jchandelle] (URB-2870)
2.6.12 (2023-09-01)
-------------------
Bug fixes:
- Fix new urban instance install
[jchandelle] (URB-2868)
- Fix facet xml configuration
[jchandelle] (URB-2870)
2.6.11 (2023-08-29)
-------------------
Bug fixes:
- Fix icon tag in table
[jchandelle] (SUP-31983)
2.6.10 (2023-08-28)
-------------------
Bug fixes:
- Avoid an error if a task was not correctly removed from catalog
[mpeeters] (URB-2873)
2.6.9 (2023-08-27)
------------------
Bug fixes:
- Fix UnicodeDecodeError on getFolderManagersSignaletic(withGrade=True)
[fngaha] (URB-2871)
2.6.8 (2023-08-24)
------------------
Bug fixes:
- fix select2 widget on folder manager
[jchandelle] (SUP-31898)
- Fix opinion schedules assigned user column
[mpeeters] (URB-2819)
2.6.7 (2023-08-14)
------------------
Bug fixes:
- Hide old document generation links viewlet
[mpeeters] (URB-2864)
2.6.6 (2023-08-10)
------------------
Bug fixes:
- Fix an issue with autocomplete view results format that was generating javascript errors
[mpeeters] (SUP-31682)
2.6.5 (2023-07-27)
------------------
Bug fixes:
- Avoid errors on inexpected values on licences and log them
[mpeeters] (SUP-31554)
- Fix translation for road adaptation vocabulary values
[mpeeters] (URB-2575)
- Avoid an error if a vocabulary does not exist, this can happen when multiple upgrade steps interract with vocabularies
[mpeeters] (URB-2835)
2.6.4 (2023-07-24)
------------------
New features:
- Add parameter to autocomplete to search with exact match
[jchandelle] (URB-2696)
Bug fixes:
- Fix an issue with some urban instances with lists that contains empty strings or `None`
[mpeeters] (URB-2575)
- Fix inspection title
[jchandelle] (URB-2830)
- Add an external method to set profile version for Products.urban
[mpeeters] (URB-2835)
2.6.3 (2023-07-18)
------------------
- Add missing translations [URB-2823]
[mpeeters, anagant]
- Fix different type of vocabulary [URB-2575]
[jchandelle]
- Change NN field position [SUP-27165]
[jchandelle]
- Add Couple to Preliminary Notice [URB-2824]
[ndemonte]
- Fix Select2 view display [URB-2575]
[jchandelle]
- Provide getLastAcknowledgment method for all urbancertificates [SUP-30852]
[fngaha]
- Fix encoding error [URB-2805]
[fngaha]
- Add a explicit dependency to collective.exportimport
[mpeeters]
- Cadastral historic memory error [SUP-30310]
[sdelcourt]
- Add option to POST endpoint when creating a licence to disable check ref format [SUP-31043]
[jchandelle]
2.6.2 (2023-07-04)
------------------
- Explicitly include `urban.restapi` zcml dependency [URB-2790]
[mpeeters]
2.6.1 (2023-07-04)
------------------
- Fix zcml for migrations
[mpeeters]
2.6.0 (2023-07-03)
------------------
- Fix `hidealloption` and `hide_category` parameters for dashboard collections
[mpeeters]
- Fix render of columns with escape parameter
[mpeeters, sdelcourt]
- Avoid a traceback if an UID was not found for inquiry cron [URB-2721]
[mpeeters]
- Migrate to the latest version of `imio.dashboard`
[mpeeters]
2.5.4 (2023-07-03)
------------------
- Change collection column name [URB-1537]
[jchandelle]
- Fix class name in external method fix_labruyere_envclassthrees [SUP-29587]
[ndemonte]
2.5.3 (2023-06-23)
------------------
- Add parcel and applicants contents to export content [URB-2733]
[jchandelle]
2.5.2 (2023-06-15)
------------------
- Fix tests and update package metadata
[sdelcourt, mpeeters]
- Add CSV import of recipients to an inquiry [URB-2573]
[ndemonte]
- Fix bound licence allowed type [SUP-27062]
[jchandelle]
- Add vat field to notary [SUP-29450]
[jchandelle]
- Change MultiSelectionWidget to MultiSelect2Widget [URB-2575]
[jchandelle]
- Add fields to legal aspect of generic licence [SUP-22944]
[jchandelle]
- Add national register number to corporation form [SUP-27165]
[jchandelle]
- Add an external method to update task delay [SUP-28870]
[jchandelle]
- Add external method to fix broken environmental declarations [SUP-29587]
[ndemonte]
- Fix export data with c.exportimport [URB-2733]
[jchandelle]
2.5.1 (2023-04-06)
------------------
- Added 'retired' transition to 'deposit' and 'incomplete' states for codt_buildlicence_workflow
[fngaha]
- Manage the display of licences linked to several applicants
[fngaha]
- Add an import step to activate 'announcementArticlesText' optional field
[fngaha]
- Fix external method [SUP-28740]
[jchandelle]
- Add external method for fixing corrupted description. [SUP-28740]
[jchandelle]
- Allow to encode dates going back to 1930
[fngaha]
- Update MailingPersistentDocumentGenerationView call with generated_doc_title param. [URB-1862]
[jjaumotte]
- Fix 0 values Bis & Puissance format for get_parcels [SUP-16626]
[jjaumotte]
- Fix 0 values Bis & Puissance format for getPortionOutText
[jjaumotte]
- Remove 'provincial' in folderroadtypes vocabulary [URB-2129]
[jjaumotte]
- Remove locality name in default text [URB-2124]
[jjaumotte]
- Remove/disable natura2000 folderzone [URB-2052]
[jjaumotte]
- Add notaries mailing [URB-2110]
[jjaumotte]
- Add copy to claymant action for recipient_cadastre in inquiry event
[sdelcourt / jjaumotte]
- Fix liste_220 title encoding error + translation [SUP-15084]
[jjaumotte]
- provides organizations to consult based on external directions
[fngaha]
- Add an Ultimate date field in the list of activatable fields
[fngaha]
- provide the add company feature to the CU1 process
[fngaha]
- Update documentation with cadastre downloading
[fngaha]
- Translate liste_220 errors
[fngaha]
- Provide the add company feature to the CU1 process
[fngaha]
- Improve mailing. Add the possibility to delay mailing during the night [SUP-12289]
[sdelcourt]
- Fix default schedule config for CODT Buildlicence [SUP-12344]
[sdelcourt]
- Allow shortcut transition to 'inacceptable' state for CODT licence wofklow. [SUP-6385]
[sdelcourt]
- Set default foldermanagers view to sort the folder with z3c.table on title [URB-1151]
[jjaumotte]
- Add some applicants infos on urban_description schemata. [URB-1171]
[jjaumotte]
- Improve default reference expression for licence references. [URB-2046]
[sdelcourt]
- Add search filter on public config folders (geometricians, notaries, architects, parcellings). [SUP-10537]
[sdelcourt]
- Migrate PortionOut (Archetype) type to Parcel (dexterity) type. [URB-2009]
[sdelcourt]
- Fix add permissions for Inquiries. [SUP-13679]
[sdelcourt]
- Add custom division 99999 for unreferenced parcels. [SUP-13835]
[sdelcourt]
- Migrate ParcellingTerm (Archetype) type to Parcelling (dexterity) type.
[sdelcourt]
- Pre-check all manageable licences for foldermanager creation. [URB-1935]
[jjaumotte]
- Add field to define final states closing all the urban events on a licence. [URB-2082]
[sdelcourt]
- Refactor key date display to include urban event custom titles. [SUP-13982]
[sdelcourt]
- Add Basebuildlicence reference field reprensentativeContacts + tests [URB-2335]
[jjaumotte]
- Licences can created as a copy of another licence (fields, applicants and parcels can be copied). [URB-1934]
[sdelcourt]
- Add collective.quickupload to do multiple file upload on licences and events.
[sdelcourt]
- Fix empty value display on select fields. [URB-2073]
[sdelcourt]
- Add new value 'simple procedure' for CODT BuildLicence procedure choice. [SUP-6566]
[sdelcourt]
- Allow multiple parcel add from the 'search parcel' view. [URB-2126]
[sdelcourt]
- Complete codt buildlicence config with 'college repport' event. [URB-2074]
[sdelcourt]
- Complete codt buildlicence schedule.
[sdelcourt]
- Add default codt notary letters schedule.
[sdelcourt]
- Add parking infos fields on road tab.
[sdelcourt]
- Remove pod templates styles form urban. [URB-2080]
[sdelcourt]
- Add authority default values to CODT_integrated_licence, CODT_unique_licence, EnvClassBordering. [URB-2269]
[mdhyne]
- Add default person title when creating applicant from a parcel search. [URB-2227]
[mdhyne]
[sdelcourt]
- Update vocabularies CODT Build Licence (folder categories, missing parts)
[lmertens]
- Add dashboard template 'listing permis'
[lmertens]
- Add translations [URB-1997]
[mdhyne]
-add boolean field 'isModificationParceloutLicence'. [URB-2250]
[mdhyne]
- Add logo urban to the tab, overriding the favicon.ico viewlet. [URB-2209]
[mdhyne]
- Add all applicants to licence title. [URB-2298]
[mdhyne]
- Add mailing loop for geometricians. [URB-2327]
[mdhyne]
- Add parcel address to parcel's identity card.[SUP-20438]
[mdhyne]
- Adapt ComputeInquiryDelay for EnvClassOne licences and Announcements events.[SUP20443]
[mdhyne]
- Include parcels owners partner in cadastral queries.[SUP-20092]
[sdelcourt]
- Add fields trail, watercourse, trailDetails, watercourseCategory and add vocabulary in global config for the fields.[MURBECAA-51]
[mdhyne]
- To use 50m radius in announcement : changes setLinkedInquiry getAllInquiries() call by getAllInquiriesAndAnnouncements() and changes condition in template urbaneventinquiryview.pt. [MURBWANAA-23]
[mdhyne]
- add new 'other' tax vocabulary entry and new linked TextField taxDetails
[jjaumotte]
- Add contact couples.
[sdelcourt]
2.4 (2019-03-25)
----------------
- add tax field in GenericLicence
[fngaha]
- add communalReference field in ParcellingTerm
[fngaha]
- Fix format_date
[fngaha]
- Update getLimitDate
[fngaha]
- Fix translations
- Update the mailing merge fields in all the mailing templates
[fngaha]
- Specify at installation the mailing source of the models that can be mailed via the context variable
[fngaha]
- Select at the installation the mailing template in all models succeptible to be mailed
[fngaha]
- Referencing the mailing template in the general templates configuration (urban and environment)
[fngaha]
- Allow content type 'MailingLoopTemplate' in general templates
[fngaha]
- added the mailing template
[fngaha]
- add mailing_list method
[fngaha]
- add a z3c.table column for mailing with his icon
[fngaha]
- fix translations
[fngaha]
- update signaletic for corporation's applicant
[fngaha]
- fix the creation of an applicant from a parcel
[fngaha]
- add generic "Permis Publics" templates and linked event configuration
[jjaumotte]
- add generic "Notary Letters" template and linked event configuration
[jjaumotte]
- fix advanced searching Applicant field for all licences, and not just 'all'
[jjaumotte]
2.3.0
-----
- Add attributes SCT, sctDetails
[fngaha]
- Add translations for SCT, sctDetails
[fngaha]
- Add vocabularies configuration for SCT
[fngaha]
- Add migration source code
[fngaha]
2.3.x (unreleased)
-------------------
- Update MultipleContactCSV methods with an optional number_street_inverted (#17811)
[jjaumotte]
1.11.1 (unknown release date)
-----------------------------
- add query_parcels_in_radius method to view
[fngaha]
- add get_work_location method to view
[fngaha]
- add gsm field in contact
[fngaha]
- improve removeItems utils
[fngaha]
- Refactor rename natura2000 field because of conflict name in thee
[fngaha]
- Refactor getFirstAdministrativeSfolderManager to getFirstGradeIdSfolderManager
The goal is to use one method to get any ids
[fngaha]
- Add generic SEVESO optional fields
[fngaha]
- Fix concentratedRunoffSRisk and details optional fields
[fngaha]
- Add getFirstAdministrativeSfolderManager method
[fngaha]
- Add removeItems utils and listSolicitOpinionsTo method
[fngaha]
- Add getFirstDeposit and _getFirstEvent method
[fngaha]
- remove the character 'à' in the address signaletic
[fngaha]
- use RichWidget for 'missingPartsDetails', 'roadMissingPartsDetails', 'locationMissingPartsDetails'
[fngaha]
- Fix local workday's method"
[fngaha]
- Add a workday method from collective.delaycalculator
refactor getUrbanEvents by adding UrbanEventOpinionRequest
rename getUrbanEventOpinionRequest to getUrbanEvent
rename containsUrbanEventOpinionRequest to containsUrbanEvent
[fngaha]
- Add methods
getUrbanEventOpinionRequests
getUrbanEventOpinionRequest
containsUrbanEventOpinionRequest
[fngaha]
- Update askFD() method
[fngaha]
- Add generic Natura2000 optional fields
[fngaha]
- Fix codec in getMultipleClaimantsCSV (when use a claimant contat)
[fngaha]
- Add generic concentratedRunoffSRisk and details optional fields
[fngaha]
- Add generic karstConstraint field and details optional fields
[fngaha]
1.11.0 (2015-10-01)
-------------------
- Nothing changed yet.
1.10.0 (2015-02-24)
-------------------
- Can add attachments directly on the licence (#10351).
1.9.0 (2015-02-17)
------------------
- Add environment licence class two.
- Use extra value for person title signaletic in mail address.
1.8.0 (2015-02-16)
------------------
- Add environment licence class one.
- Bug fix: config folder are not allowed anymore to be selected as values
for the field 'additionalLegalConditions'.
1.7.0
-----
- Add optional field RGBSR.
- Add field "deposit type" for UrbanEvent (#10263).
1.6.0
-----
- Use sphinx to generate documentation
- Add field "Périmètre de Rénovation urbaine"
- Add field "Périmètre de Revitalisation urbaine"
- Add field "Zones de bruit de l'aéroport"
1.5.0
-----
- Update rubrics and integral/sectorial conditions vocabularies
1.4.0
-----
- Add schedule view
1.3.0
-----
- Use plonetheme.imioapps as theme rather than urbasnkin
- Add fields "pm Title" and "pm Description" on urban events to map the fields "Title"
and "Description" on plonemeeting items (#7147).
- Add a richer context for python expression in urbanEvent default text.
- Factorise all licence views through a new generic, extendable and customisab | null | Simon Delcourt | simon.delcourt@imio.be | null | null | GPL | Urban IMIO | [
"License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
"Programming Language :: Python",
"Programming Language :: Python :: 2.7"
] | [] | http://www.communesplone.org/les-outils/applications-metier/gestion-des-permis-durbanisme | null | null | [] | [] | [] | [
"archetypes.referencebrowserwidget",
"collective.ckeditor",
"collective.datagridcolumns",
"collective.delaycalculator",
"collective.documentgenerator>=3.20",
"collective.externaleditor",
"collective.exportimport",
"collective.faceted.datewidget",
"collective.fingerpointing",
"collective.iconifieddocumentactions",
"collective.js.jqueryui",
"collective.messagesviewlet",
"collective.noindexing",
"collective.wfadaptations",
"collective.z3cform.datagridfield>=0.15",
"collective.archetypes.select2",
"dm.historical",
"five.grok",
"grokcore.component",
"imio.actionspanel",
"imio.dashboard",
"imio.pm.locales",
"imio-pm-wsclient>=2.0.5",
"imio.restapi",
"imio.schedule",
"imio.urban.core",
"imio.ws.register",
"Pillow",
"Plone",
"Products.CMFPlacefulWorkflow",
"Products.ContentTypeValidator",
"Products.CPUtils",
"Products.DataGridField",
"Products.MasterSelectWidget",
"Products.PasswordStrength",
"plone.api",
"plone.app.contenttypes",
"plone.app.referenceintegrity",
"plone.namedfile",
"plone.z3ctable",
"plonetheme.imioapps",
"Products.cron4plone",
"psycopg2",
"python-dateutil",
"python-Levenshtein",
"requests",
"setuptools",
"Sphinx",
"SQLAlchemy",
"testfixtures",
"zope.app.container",
"zope.sqlalchemy",
"urban.restapi",
"urban.vocabulary",
"urban.schedule",
"urban.events",
"python-dateutil",
"PyMySQL",
"ipdb; extra == \"test\"",
"mock; extra == \"test\"",
"plone.app.robotframework[debug,test]; extra == \"test\"",
"plone.app.testing; extra == \"test\"",
"plone.testing; extra == \"test\"",
"testfixtures; extra == \"test\"",
"unittest2; extra == \"test\"",
"zope.testing; extra == \"test\"",
"Genshi; extra == \"templates\"",
"numpy; extra == \"numpy\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.7 | 2026-02-20T14:18:21.087556 | products_urban-2.9.11.tar.gz | 20,516,455 | 7d/af/117ade09eae74d7b0567b6a76bfc938e5ac8e8c0d9e03369d7a935224759/products_urban-2.9.11.tar.gz | source | sdist | null | false | 7f1108408f1fb7a6f3ded80df9e9045d | a49ef2b478204b5068b953dbe8e3c7dfcb6f6383daf0cbe7342c1032b0f478e8 | 7daf117ade09eae74d7b0567b6a76bfc938e5ac8e8c0d9e03369d7a935224759 | null | [] | 0 |
2.1 | odoo-addon-spreadsheet-oca | 18.0.1.1.1 | Allow to edit spreadsheets | .. image:: https://odoo-community.org/readme-banner-image
:target: https://odoo-community.org/get-involved?utm_source=readme
:alt: Odoo Community Association
===============
Spreadsheet Oca
===============
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:65bc318ca4bd4e29a941983b95b811a2ba7e83b816554ba06a37a7cd4ff0dd64
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fspreadsheet-lightgray.png?logo=github
:target: https://github.com/OCA/spreadsheet/tree/18.0/spreadsheet_oca
:alt: OCA/spreadsheet
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/spreadsheet-18-0/spreadsheet-18-0-spreadsheet_oca
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/spreadsheet&target_branch=18.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
This module adds a functionality for adding and editing Spreadsheets
using Odoo CE.
It is an alternative to the proprietary module ``spreadsheet_edition``
of Odoo Enterprise Edition.
**Table of contents**
.. contents::
:local:
Usage
=====
**Create a new spreadsheet**
----------------------------
- Go to 'Spreadsheet' menu
- Click on 'Create'
- Put a name, then click on the "Edit" button
|image1|
- At this point you switch to spreadsheet editing mode. The editor is
named ``o-spreadsheet`` and looks like another common spreadsheet web
editors. (OnlyOffice, Ethercalc, Google Sheets (non-free)).
|image2|
- You can use common functions ``SUM()``, ``AVERAGE()``, etc. in the
cells. For a complete list of functions and their syntax, Refer to the
documentation https://github.com/odoo/o-spreadsheet/ or go to
https://odoo.github.io/o-spreadsheet/ and click on "Insert >
Function".
|image3|
- Note: Business Odoo module can add "business functions". This is
currently the case for the accounting module, which adds the following
features:
- ``ODOO.CREDIT(account_codes, date_range)``: Get the total credit
for the specified account(s) and period.
- ``ODOO.DEBIT(account_codes, date_range)``: Get the total debit
for the specified account(s) and period.
- ``ODOO.BALANCE(account_codes, date_range)``: Get the total
balance for the specified account(s) and period.
- ``ODOO.FISCALYEAR.START(day)``: Returns the starting date of the
fiscal year encompassing the provided date.
- ``ODOO.FISCALYEAR.END(day)``: Returns the ending date of the
fiscal year encompassing the provided date.
- ``ODOO.ACCOUNT.GROUP(type)``: Returns the account ids of a given
group where type should be a value of the ``account_type`` field
of ``account.account`` model. (``income``, ``asset_receivable``,
etc.)
.. |image1| image:: https://raw.githubusercontent.com/OCA/spreadsheet/18.0/spreadsheet_oca/static/description/spreadsheet_create.png
.. |image2| image:: https://raw.githubusercontent.com/OCA/spreadsheet/18.0/spreadsheet_oca/static/description/spreadsheet_edit.png
.. |image3| image:: https://raw.githubusercontent.com/OCA/spreadsheet/18.0/spreadsheet_oca/static/description/o-spreadsheet.png
Development
===========
If you want to develop custom business functions, you can add others,
based on the file
https://github.com/odoo/odoo/blob/16.0/addons/spreadsheet_account/static/src/accounting_functions.js
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/spreadsheet/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/spreadsheet/issues/new?body=module:%20spreadsheet_oca%0Aversion:%2018.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* CreuBlanca
Contributors
------------
- Enric Tobella
- `Tecnativa <https://www.tecnativa.com>`__:
- Carlos Roca
- `Open User Systems <https://www.openusersystems.com>`__:
- Chris Mann
- `Mind And Go <https://mind-and-go.com>`__
- Florent THOMAS
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
This module is part of the `OCA/spreadsheet <https://github.com/OCA/spreadsheet/tree/18.0/spreadsheet_oca>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | CreuBlanca,Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 18.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/spreadsheet | null | >=3.10 | [] | [] | [] | [
"odoo==18.0.*"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:18:19.713440 | odoo_addon_spreadsheet_oca-18.0.1.1.1-py3-none-any.whl | 949,725 | 02/5a/27ddef796b55bd07bd956b23304fb84729bf7e2b23794cdb0ace4b2d61d2/odoo_addon_spreadsheet_oca-18.0.1.1.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 9eb0546374750081faa3b76f0a995b99 | 928da25bb29dd8f052da49126a441f9fd8c4cfc84a9d590441e064286bf3b9f2 | 025a27ddef796b55bd07bd956b23304fb84729bf7e2b23794cdb0ace4b2d61d2 | null | [] | 82 |
2.4 | yta-editor-time | 0.0.11 | Youtube Autonomous Editor Time Module. | # Youtube Autonomous Editor Time Module
The module related to the time and how we handle it perfectly in our editor. | text/markdown | danialcala94 | danielalcalavalera@gmail.com | null | null | null | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9"
] | [] | null | null | ==3.9 | [] | [] | [] | [
"yta_constants<1.0.0,>=0.0.1",
"yta_video_frame_time<1.0.0,>=0.0.1"
] | [] | [] | [] | [] | poetry/2.2.0 CPython/3.9.0 Windows/10 | 2026-02-20T14:17:23.491011 | yta_editor_time-0.0.11.tar.gz | 6,862 | 88/73/c885f97fde08bd45952b7c07f06414410a6b19ec2a95a8fecbafc6a260c9/yta_editor_time-0.0.11.tar.gz | source | sdist | null | false | 8babb1f9eb9c185bb09de83f92c41c72 | 199f2578bb486a974435875b63ee46f0813e0deec1fbd8222204e96691da6435 | 8873c885f97fde08bd45952b7c07f06414410a6b19ec2a95a8fecbafc6a260c9 | null | [] | 185 |
2.4 | ionworks-schema | 0.1.4 | Pydantic schemas for building Ionworks pipeline configurations | # Ionworks Schema
Pydantic schemas for building Ionworks pipeline configurations.
## Overview
**Ionworks Schema** (`ionworks_schema`) provides the schema for constructing [Ionworks pipeline configurations](https://pipeline.docs.ionworks.com/). Use these classes to define pipelines (data fits, calculations, entries, validations) in Python with validation, then export JSON to submit via the Ionworks API. Pipeline concepts, objectives, and workflows are described in the [Pipeline documentation](https://pipeline.docs.ionworks.com/) and in the [Ionworks documentation](https://docs.ionworks.com).
Pipelines are **executed by submitting configurations** to the Ionworks API. Use the [ionworks-api](https://github.com/ionworks/ionworks-api) Python client to create and run jobs: `pip install ionworks-api`.
## Installation
```bash
pip install ionworks_schema
```
## Quick start
Build a pipeline configuration with schema classes, export to JSON, and submit with the Ionworks API client:
```python
import ionworks_schema as iws
import json
# Define a parameter to fit (name, initial_value, bounds)
parameter = iws.Parameter(
name="Positive electrode capacity [A.h]",
initial_value=1.0,
bounds=(0.5, 2.0),
)
# Objective: MSMR half-cell fit; data can be "db:<measurement_id>" for uploaded data (use objectives submodule)
objective = iws.objectives.MSMRHalfCell(
data_input="db:your-measurement-id",
options={"model": {"electrode": "positive"}},
)
data_fit = iws.DataFit(
objectives={"ocp": objective},
parameters={"Positive electrode capacity [A.h]": parameter},
)
pipeline = iws.Pipeline(elements={"fit": data_fit})
# Export to JSON for API submission
config = pipeline.to_config()
with open("pipeline_config.json", "w") as f:
json.dump(config, f, indent=2)
# Submit via ionworks-api (requires credentials and project ID — see ionworks-api README)
# from ionworks import Ionworks
# client = Ionworks()
# job = client.pipeline.create(config)
# client.pipeline.wait_for_completion(job.id, timeout=600)
```
## Schema classes and pipeline elements
Schema classes mirror the pipeline configuration format consumed by the Ionworks pipeline and API. Runtime behavior and options are documented in the [Pipeline user guide](https://pipeline.docs.ionworks.com/) and in the `ionworkspipeline` package (e.g. parsers, `data_fits`, `objectives`).
A pipeline is a top-level **`Pipeline`** with a dictionary of named **elements**. Each element has an `element_type`: `entry`, `data_fit`, `calculation`, or `validation`.
| Role | Schema class | Description |
|------|--------------|-------------|
| **Top-level** | `Pipeline` | Pipeline configuration with named `elements`. |
| **Entry** | `DirectEntry` | Supply fixed parameter values (no fitting or calculation). |
| **Data fit** | `DataFit`, `ArrayDataFit` | Fit model parameters to data; contain `objectives` and `parameters`. |
| **Calculation** | `ionworks_schema.calculations` | Run calculations (e.g. OCP, diffusivity, geometry). See submodule for available classes. |
| **Objectives** | `MSMRHalfCell`, `MSMRFullCell`, `CurrentDriven`, `CycleAgeing`, `CalendarAgeing`, `EIS`, `Pulse`, `Resistance`, `ElectrodeBalancing`, `OCPHalfCell`, and others | Used inside `DataFit.objectives` to define what to fit. Import from `ionworks_schema.objectives` (e.g. `iws.objectives.MSMRHalfCell`). |
| **Parameters** | `Parameter` | `name`, `initial_value`, `bounds` (and optional prior, etc.). Used in `DataFit.parameters`; dict key is the parameter name. |
| **Priors** | `Prior` | Used in `DataFit.priors`. Import from `ionworks_schema.priors` (e.g. `iws.priors.Prior`). |
| **Library** | `Material`, `Library` | Built-in material library for initial parameter values. |
## Material library
Access built-in materials with validated parameter values for use as initial values or entries:
```python
import ionworks_schema as iws
# List available materials
materials = iws.Library.list_materials()
# Get a specific material (e.g. NMC - Verbrugge 2017)
material = iws.Material.from_library("NMC - Verbrugge 2017")
print(material.parameter_values)
```
Parameter names and interpretation are described in the [Pipeline documentation](https://pipeline.docs.ionworks.com/).
## Resources
- [Pipeline documentation](https://pipeline.docs.ionworks.com/) — workflows, objectives, data fits, and pipeline concepts.
- [ionworks-api](https://github.com/ionworks/ionworks-api) — submit and manage pipelines (`pip install ionworks-api`).
- [Ionworks documentation](https://docs.ionworks.com) — product and platform documentation.
## Note
This package provides configuration schemas only. To run pipelines, export JSON with `pipeline.to_config()` and submit it via the Ionworks API using the [ionworks-api](https://github.com/ionworks/ionworks-api) client.
| text/markdown | null | Ionworks <info@ionworks.com> | null | null | null | ionworks, battery, pydantic, schema, pipeline | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"pydantic>=2.0",
"numpy",
"pandas",
"pytest; extra == \"dev\"",
"pytest-cov; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://ionworks.com",
"Documentation, https://docs.ionworks.com",
"Repository, https://github.com/ionworks/ionworks-schema"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:17:22.535508 | ionworks_schema-0.1.4.tar.gz | 568,410 | 84/5e/2b17d1426f5337bcc4624f81f4b827af6c1664d9768e95ac031c420b710e/ionworks_schema-0.1.4.tar.gz | source | sdist | null | false | eb698c73936a82fb21978ea733a1a232 | f08b6b28daf62143815014a5a82c94b584f4a1ee0d1420267af5e34b96f89fcb | 845e2b17d1426f5337bcc4624f81f4b827af6c1664d9768e95ac031c420b710e | null | [
"LICENSE"
] | 231 |
2.4 | mtgwants | 0.1.0 | A Python CLI tool for arithmetic operations on Magic: The Gathering Cockatrice deck files | # 🃏 MTG Wants - Cockatrice Deck Operations
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/Firi0n/mtgwants)
A powerful Python CLI tool and library for performing arithmetic operations on Magic: The Gathering deck files in Cockatrice format (.cod). Perfect for deck management, inventory tracking, and wantslist generation for Cardmarket.
## ✨ Features
- 🔢 **Deck Arithmetic**: Add and subtract decks with `--add` and `--sub` operations
- 📦 **Sideboard Support**: Full support for sideboard management
- 🎯 **Cardmarket Integration**: Export formatted wantslists ready to paste into Cardmarket
- 🔄 **Sequential Operations**: Chain multiple operations in exact order
- 📁 **Cockatrice Compatible**: Native support for Cockatrice .cod XML format
- 🐍 **Python Library**: Use as a CLI tool or import as a Python library
- 🚀 **Zero Dependencies**: Built entirely on Python standard library
## 🎮 Use Cases
- **Build a wantslist**: Subtract your collection from a target deck to know what to buy
- **Combine decks**: Merge multiple decklists into one
- **Track inventory**: Keep your digital collection synchronized with physical cards
- **Deck variations**: Create deck variants by adding/removing specific cards
- **Budget planning**: Calculate exact cards needed for deck upgrades
## 📦 Installation
### From PyPI (Coming Soon)
```bash
pip install mtgwants
```
### From Source
```bash
git clone https://github.com/Firi0n/mtgwants.git
cd mtgwants
pip install -e .
```
## 🚀 Quick Start
### Basic Usage
```bash
# Save a single deck
mtgwants main.cod -o output.cod
# Create a wantslist: deck minus your collection
mtgwants deck.cod --sub collection.cod --print
# Combine multiple decks with sideboard
mtgwants deck1.cod --add deck2.cod --add deck3.cod --sideboard -o combined.cod
```
## 📖 Documentation
### Command Line Interface
```
mtgwants MAIN_DECK [OPTIONS]
```
#### Required Arguments
- `MAIN_DECK`: The primary deck file in Cockatrice .cod format
#### Deck Operations
| Option | Short | Description |
|--------|-------|-------------|
| `--add DECK.COD` | `-a` | Add cards from deck file (repeatable) |
| `--sub DECK.COD` | `-b` | Subtract cards from deck file (repeatable) |
**Important**: Operations are executed in the **exact order** you specify them on the command line. Order matters because subtraction doesn't produce negative quantities.
#### Other Options
| Option | Short | Description |
|--------|-------|-------------|
| `--sideboard` | `-s` | Include sideboard from all decks |
| `--output FILE` | `-o` | Save result to a .cod file |
| `--print` | `-p` | Print cardlist to console (Cardmarket format) |
| `--deck-name NAME` | `-n` | Custom name for output deck (default: "Deck") |
| `--verbose` | `-v` | Verbose output (use `-vv` for extra detail) |
**Note**: At least one of `--output` or `--print` must be specified.
### 📚 Examples
#### Example 1: Generate a Wantslist
You want to build a Commander deck but need to know which cards to buy:
```bash
mtgwants commander_deck.cod --sub my_collection.cod --sideboard --print
```
This outputs a formatted list you can paste directly into Cardmarket's wantslist.
#### Example 2: Combine Decklists
Merge several decklists into one master list:
```bash
mtgwants deck1.cod --add deck2.cod --add deck3.cod -o master_deck.cod
```
#### Example 3: Track Inventory
After buying cards, update your collection and recalculate what you still need:
```bash
mtgwants target_deck.cod --sub old_collection.cod --add new_cards.cod -o updated_needs.cod --print
```
#### Example 4: Short Form Syntax
Use abbreviated flags for quicker commands:
```bash
mtgwants main.cod -a extras.cod -b dupes.cod -o final.cod -p
```
#### Example 5: Order Matters
Operations are executed left-to-right in exact order:
```bash
# Add first, then subtract
mtgwants deck.cod --add new.cod --sub owned.cod -p
# Result: (deck + new) - owned
# Different order, different result
mtgwants deck.cod --sub owned.cod --add new.cod -p
# Result: (deck - owned) + new
```
#### Example 6: Debug with Verbose Output
See detailed information about each operation:
```bash
mtgwants main.cod -a extras.cod -b dupes.cod -o final.cod -vv
```
Output:
```
Loading main deck: main.cod
Main: 60 cards
Adding: extras.cod
Result main: 75 cards
Subtracting: dupes.cod
Result main: 60 cards
Saving to: final.cod
✓ Saved successfully
✓ Operations completed successfully
Final deck: 60 cards in main
```
### 🐍 Python Library Usage
Use `mtgwants` as a library in your Python projects:
```python
from mtgwants import Card, Zone, Deck, CockatriceParser
# Create parser
parser = CockatriceParser(sideboard=True)
# Load decks
deck1 = parser.load("deck1.cod")
deck2 = parser.load("deck2.cod")
# Perform operations
combined = deck1 + deck2
needs = deck1 - deck2
# Access card data
for card, quantity in combined.main.items():
print(f"{quantity}x {card.name}")
# Save result
parser.save(combined, "output.cod", "My Combined Deck")
```
#### Core Classes
##### `Card`
Represents a Magic: The Gathering card identified by name.
```python
card = Card("Lightning Bolt")
print(card.name) # "Lightning Bolt"
```
##### `Zone`
A multiset of cards with arithmetic operations (main deck, sideboard, etc.).
```python
zone = Zone({Card("Lightning Bolt"): 4, Card("Counterspell"): 2})
print(len(zone)) # 6 (total cards)
print(zone.unique_cards) # 2 (different cards)
```
##### `Deck`
Complete deck with main zone and optional sideboard.
```python
main = Zone({Card("Lightning Bolt"): 4})
side = Zone({Card("Counterspell"): 2})
deck = Deck(main, side)
print(deck.has_sideboard) # True
print(len(deck)) # 6 (main + sideboard)
```
##### `CockatriceParser`
Parser for reading and writing .cod files.
```python
parser = CockatriceParser(sideboard=True)
deck = parser.load("deck.cod")
parser.save(deck, "output.cod", "Deck Name")
```
## 🛠️ Technical Details
### File Format
Cockatrice .cod files are XML files with the following structure:
```xml
<?xml version="1.0"?>
<cockatrice_deck version="1">
<deckname>My Deck</deckname>
<comments></comments>
<zone name="main">
<card number="4" name="Lightning Bolt"/>
<card number="2" name="Counterspell"/>
</zone>
<zone name="side">
<card number="3" name="Negate"/>
</zone>
</cockatrice_deck>
```
### Cardmarket Export Format
The `--print` option generates output ready for Cardmarket's "Add a Deck List" feature:
```
4 Lightning Bolt
2 Counterspell
// Sideboard
3 Negate
```
Basic lands (Plains, Island, Swamp, Mountain, Forest, Wastes) are automatically excluded from the output.
**After pasting into Cardmarket:**
1. Select all cards → Edit
2. Set language, condition, and foil preferences
3. Save your wantslist
### Arithmetic Operations
Operations follow mathematical rules:
- **Addition**: Combines card quantities
```python
deck1 = Zone({Card("Bolt"): 2})
deck2 = Zone({Card("Bolt"): 2})
result = deck1 + deck2 # {Card("Bolt"): 4}
```
- **Subtraction**: Removes cards (negatives become zero)
```python
deck = Zone({Card("Bolt"): 4})
owned = Zone({Card("Bolt"): 2})
needs = deck - owned # {Card("Bolt"): 2}
```
- **Sequential Operations**: Processed in exact command-line order (left to right)
```bash
mtgwants A.cod --add B.cod --sub C.cod --add D.cod
# Equivalent to: (((A + B) - C) + D)
```
## 📋 Requirements
- Python 3.10 or higher
- No external dependencies (uses only Python standard library)
## 🤝 Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request
## 📝 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## 🎯 Roadmap
- [ ] Cardmarket API integration (when/if they finally release it to private users)
## 💡 FAQ
**Q: Why "mtgwants"?**
A: The tool was originally designed to generate wantslists for Cardmarket by subtracting your collection from target decks.
**Q: Does this work with other MTG software?**
A: Currently only Cockatrice .cod format is supported. Other formats are planned.
**Q: What about the Cardmarket API?**
A: Cardmarket's API v3.0 for private users has been "coming soon" since 2021. Until then, use the `--print` option for manual import.
**Q: Can I use this in my own Python project?**
A: Absolutely! Import the library and use the `Card`, `Zone`, `Deck`, and `CockatriceParser` classes.
## 🙏 Acknowledgments
- [Cockatrice](https://cockatrice.github.io/) - Open source MTG client
- [Cardmarket](https://www.cardmarket.com/) - European MTG marketplace
- The Magic: The Gathering community
## 📞 Contact
- GitHub: [@Firi0n](https://github.com/Firi0n)
- Project Link: [https://github.com/Firi0n/mtgwants](https://github.com/Firi0n/mtgwants)
---
⭐ If you find this tool useful, please consider giving it a star on GitHub!
| text/markdown | Pasquale Rossini | null | null | null | null | magic, mtg, cockatrice, deck, cardmarket, wantslist | [
"Development Status :: 4 - Beta",
"Intended Audience :: End Users/Desktop",
"Topic :: Games/Entertainment :: Board Games",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/Firi0n/mtgwants",
"Bug Reports, https://github.com/Firi0n/mtgwants/issues",
"Source, https://github.com/Firi0n/mtgwants"
] | twine/6.2.0 CPython/3.10.19 | 2026-02-20T14:16:44.419782 | mtgwants-0.1.0.tar.gz | 15,838 | b9/1c/755ad1e310031150fbfdcc77a8c998930713a9fdc857cc0e7d305c8a2b82/mtgwants-0.1.0.tar.gz | source | sdist | null | false | 8553b846e8f61c925805a909098425b6 | 0dead844c77c1bf0e8e7ff757d751033e3faf1d86a1b8c40d4ad6fe29f4a48c9 | b91c755ad1e310031150fbfdcc77a8c998930713a9fdc857cc0e7d305c8a2b82 | null | [
"LICENSE"
] | 210 |
2.4 | kubepolicy | 1.0.0 | A fast, CI-native Kubernetes policy engine with clean UX and GitHub Security integration | # kubepolicy
[](https://badge.fury.io/py/kubepolicy)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/akintunero/kube-guard)
**A fast, CI-native Kubernetes policy engine with clean UX and GitHub Security integration.**
Not "just a linter"—kubepolicy evaluates your Kubernetes YAML against security, reliability, cost, and best-practice rules, with **SARIF output** so findings appear in the GitHub Security tab.
## Features
- **Recursive YAML scanning** with multi-document support
- **Parallel scanning** for speed
- **10 built-in rules** (security, reliability, cost, best practice)
- **Config file** (`.kubepolicy.yaml`) to disable rules or override severity
- **Output formats**: table (default), JSON, **SARIF** (GitHub Code Scanning)
- **Exit code** control: fail CI when findings meet a severity threshold (`--fail-on`)
## Install
### From PyPI (recommended)
```bash
pip install kubepolicy
```
### From source
```bash
git clone https://github.com/akintunero/kube-guard.git
cd kube-guard
pip install -e .
```
### Development setup
```bash
git clone https://github.com/akintunero/kube-guard.git
cd kube-guard
pip install -e ".[dev]"
pytest tests -v
```
## Quick start
```bash
# Scan current directory (default: table output)
kubepolicy scan ./
# JSON output
kubepolicy scan ./ --format json
# SARIF for GitHub Security tab (e.g. in CI)
kubepolicy scan ./ --format sarif > results.sarif
# Fail CI on MEDIUM or higher
kubepolicy scan ./ --fail-on MEDIUM
# List all rules
kubepolicy list-rules
# Explain a rule
kubepolicy explain SEC001
# Create sample config
kubepolicy init
```
## Built-in rules (10)
| ID | Title | Severity | Category |
|----------|----------------------------|-----------|--------------|
| SEC001 | Privileged container | CRITICAL | security |
| SEC002 | Missing resource limits | MEDIUM | security |
| SEC003 | Use of latest tag | MEDIUM | security |
| SEC004 | hostPath usage | HIGH | security |
| SEC005 | Run as root | HIGH | security |
| SEC006 | Allow privilege escalation | HIGH | security |
| REL001 | Missing liveness probe | MEDIUM | reliability |
| REL002 | Missing readiness probe | MEDIUM | reliability |
| COST001 | No resource requests | MEDIUM | cost |
| BP001 | Image pull policy misconfig| LOW | best_practice|
## Config file
Create `.kubepolicy.yaml` in your repo (or run `kubepolicy init`):
```yaml
disable:
- BP001
severity_overrides:
COST001: HIGH
```
## GitHub Security integration (SARIF)
In GitHub Actions, run kubepolicy and upload the SARIF file:
```yaml
- name: Run kubepolicy
run: kubepolicy scan ./ --format sarif > kubepolicy-results.sarif || true
- name: Upload SARIF
uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: kubepolicy-results.sarif
```
Findings will appear under **Security → Code scanning** in your repository.
## Pre-commit
Example hook (run kubepolicy on staged YAML):
```yaml
# .pre-commit-hooks.yaml
- repo: local
hooks:
- id: kubepolicy
name: kubepolicy scan
entry: kubepolicy scan
language: system
types: [yaml]
args: [.]
```
## Comparison with kube-linter
| | kubepolicy | kube-linter |
|-------------------------|-------------------|------------------|
| SARIF / GitHub Security | ✅ Native | Via custom |
| Config file | ✅ .kubepolicy.yaml| ✅ |
| Fail-on severity | ✅ | ✅ |
| Parallel scan | ✅ | — |
| Python 3.11+ | ✅ | Go |
| Extensibility | Rule registry | Custom checks |
kubepolicy is designed to be **CI-first** and **GitHub-native**, with a small, focused rule set and minimal dependencies.
## Requirements
- Python 3.11+
- Typer, ruamel.yaml, Rich (see `pyproject.toml`)
## Development
See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on contributing to kubepolicy.
Quick start:
```bash
# Clone the repository
git clone https://github.com/akintunero/kube-guard.git
cd kube-guard
# Install in development mode with dev dependencies
pip install -e ".[dev]"
# Run tests
pytest tests -v
# Run with coverage
pytest tests --cov=kubepolicy --cov-report=html
```
## Project Status
kubepolicy is in **active development**. We welcome contributions, bug reports, and feature requests!
- 🐛 **Found a bug?** [Open an issue](https://github.com/akintunero/kube-guard/issues)
- 💡 **Have a feature idea?** [Start a discussion](https://github.com/akintunero/kube-guard/discussions)
- 🤝 **Want to contribute?** See [CONTRIBUTING.md](CONTRIBUTING.md)
## Roadmap
- [ ] Additional security rules (network policies, RBAC, etc.)
- [ ] Custom rule support via plugins
- [ ] Integration with other CI/CD platforms (GitLab, Jenkins, etc.)
- [ ] Performance optimizations for large codebases
- [ ] Rule severity auto-tuning based on context
## Changelog
See [CHANGELOG.md](CHANGELOG.md) for a list of changes and version history.
## License
MIT License. See [LICENSE](LICENSE) for details.
## Author
**Olúmáyòwá Akinkuehinmi**
- Email: akintunero101@gmail.com
- GitHub: [@akintunero](https://github.com/akintunero)
## Acknowledgments
- Inspired by tools like [kube-linter](https://github.com/stackrox/kube-linter) and [kube-score](https://github.com/zegl/kube-score)
- Built with [Typer](https://typer.tiangolo.com/), [ruamel.yaml](https://yaml.readthedocs.io/), and [Rich](https://rich.readthedocs.io/)
| text/markdown | null | Olúmáyòwá Akinkuehinmi <akintunero101@gmail.com> | null | null | MIT | kubernetes, policy, security, lint, sarif, ci | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: System Administrators",
"Intended Audience :: Information Technology",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Software Development :: Quality Assurance",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: Utilities"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"typer>=0.9.0",
"ruamel.yaml>=0.18.0",
"rich>=13.0.0",
"pytest>=7.0; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"pre-commit>=3.0; extra == \"dev\""
] | [] | [] | [] | [
"Repository, https://github.com/akintunero/kube-guard",
"Documentation, https://github.com/akintunero/kube-guard#readme"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:16:16.289205 | kubepolicy-1.0.0.tar.gz | 19,922 | 95/a0/6a8f9475f567f54e08e1672df3718a22c7a76b0df00771bd00a46204217d/kubepolicy-1.0.0.tar.gz | source | sdist | null | false | 96c9cfd8a26a7dde4da111bcf73b4c80 | 645a1c0ecf3a46b4fc53a6f2ddff620faec2ffd3901337c068cb72fdb6431aa4 | 95a06a8f9475f567f54e08e1672df3718a22c7a76b0df00771bd00a46204217d | null | [
"LICENSE"
] | 203 |
2.4 | IBB-Helper | 0.4.15 | Helper functions for symbolic math, matrix visualization, and plotting | ## Helper functions for symbolic math, matrix visualization, and plotting
**Author:** University of Stuttgart, Institute for Structural Mechanics (IBB)
**License:** BSD3
**Version:** 0.4.15
**Date:** Feb 20, 2026
### Description
This helper module currently provides 11 specialized functions for symbolic mathematics, matrix visualization, and plotting operations. Designed for SymPy, NumPy, Matplotlib, and Plotly integration in Jupyter Notebooks and Python environments.
### Helper Functions
1. **animate** - Animate 2D curves from symbolic expressions or datasets
2. **combine_plots** - Stack multiple Matplotlib/Plotly plots into combined figures
3. **display** - Format scalars, vectors, or matrices in LaTeX for display
4. **display_eigen** - Compute and display eigenvalues/eigenvectors with LaTeX formatting
5. **display_matrix** - Display truncated matrices with optional numerical evaluation
6. **extend_plot** - Merge multiple plots side-by-side with horizontal offsets
7. **minimize** - General optimization wrapper for symbolic expressions with constraints
8. **num_int** - Numerically integrate symbolic expressions over 1D domains using composite Gauss quadrature
9. **plot_2d** - Plot symbolic expressions or datasets in 2D using Matplotlib
10. **plot_3d** - Plot symbolic 3D surfaces using Plotly for interactive visualization
11. **plot_param_grid** - Plot 2D parametric surface grids with control points
12. **symbolic_BSpline** - Generate symbolic B-spline basis functions with plotting
### Dependencies
- Python 3.8+
- numpy, sympy, matplotlib, plotly
- IPython (for LaTeX rendering)
### Quick Start
```python
import IBB_Helper as ibb
# Display matrix
ibb.display_matrix(np.array([[1, 2], [3, 4]]), name="A")
# Show symbolic expression
ibb.display(sp.sin(x)**2 + sp.cos(x)**2, name="Identity")
# Plot 2D curves
ibb.plot_2d([sp.sin(x), sp.cos(x)], var=(x, (-np.pi, np.pi)))
# Plot 3D surface
ibb.plot_3d(sp.sin(x*y), var=(x, (-2, 2), y, (-2, 2)))
```
### Development Status
This is an **ongoing project** with regular enhancements. Updates might include:
- New helper functions
- Performance optimizations
- Extended compatibility
- Bug fixes and stability improvements
### Notes
- Optimized for education, research, and technical documentation
- Seamless SymPy/NumPy integration
- Enhanced LaTeX formatting for presentations
| text/markdown | null | "University of Stuttgart, Institute for Structural Mechanics (IBB)" <mvs@ibb.uni-stuttgart.de> | null | null | null | null | [
"Programming Language :: Python :: 3",
"Operating System :: OS Independent"
] | [] | null | null | null | [] | [] | [] | [
"numpy>=1.19",
"sympy>=1.8",
"matplotlib>=3.3",
"plotly>=5.0",
"ipython>=7.0"
] | [] | [] | [] | [
"repository, https://www.ibb.uni-stuttgart.de/en/"
] | twine/6.2.0 CPython/3.12.10 | 2026-02-20T14:16:10.191957 | ibb_helper-0.4.15.tar.gz | 22,401 | a8/e7/2056194e172f7bb2d737fbe0769df1e8b057aa3dc33803324405a1869689/ibb_helper-0.4.15.tar.gz | source | sdist | null | false | 687ea0ca7a1902dfa7f701305f29cdb5 | 219f64e2fae30e6bff04dcee7d120667d6c806de9994baccd5c699c8ae68ce55 | a8e72056194e172f7bb2d737fbe0769df1e8b057aa3dc33803324405a1869689 | BSD-3-Clause | [
"LICENSE"
] | 0 |
2.4 | synaptic-core | 0.0.1 | Placeholder package reserved for Synaptic Core. | # synaptic-core
Coming soon.
| text/markdown | null | Xavier Hillman <xhillman13@gmail.com> | null | null | null | null | [
"Development Status :: 1 - Planning",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.8 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.4 | 2026-02-20T14:15:40.149270 | synaptic_core-0.0.1.tar.gz | 1,285 | dd/f1/ee56b9b91449c72ee601338a40799638d314d5569c0b2d428eb08adec3f8/synaptic_core-0.0.1.tar.gz | source | sdist | null | false | ce6f8c0bab4648f464aa9b08f08cd6c5 | 1a7fbf1129a4994cb2def7271ddb16d9cb7c652b7e7b36167acb6d594620b339 | ddf1ee56b9b91449c72ee601338a40799638d314d5569c0b2d428eb08adec3f8 | null | [] | 151 |
2.4 | rquote | 0.5.9 | Mostly day quotes of cn/hk/us/fund/future markets, side with quote list fetch | # rquote
`rquote` 是一个提供 A股/港股/美股/ETF基金/期货 历史数据获取的Python库
## 版本信息
当前版本：**0.5.6**
## 主要特性
- ✅ 支持多市场数据获取（A股、港股、美股、期货、基金）
- ✅ 统一的API接口，使用简单
- ✅ 内置缓存机制，提升性能
- ✅ 完善的错误处理和异常体系
- ✅ 可配置的HTTP客户端（超时、重试等）
- ✅ 模块化设计，易于扩展
## 安装
```bash
pip install rquote
```
或使用 uv：
```bash
uv pip install rquote
```
## 快速开始
### 基本使用
```python
from rquote import get_price
# 获取上证指数数据
sid, name, df = get_price('sh000001')
print(df.head()) # 数据为pandas DataFrame
```
### 获取指定日期范围的数据
```python
# 获取指定日期范围的数据
sid, name, df = get_price('sz000001', sdate='2024-01-01', edate='2024-02-01')
```
### 使用缓存
#### 内存缓存（MemoryCache）
```python
from rquote import get_price, MemoryCache
# 创建缓存实例（ttl 单位：秒）
cache = MemoryCache(ttl=3600) # 缓存 1 小时
# 使用缓存（通过dd参数传递MemoryCache实例）
sid, name, df = get_price('sh000001', dd=cache)
# 注意：MemoryCache 是内存缓存，数据仅在当前进程运行期间有效
# 脚本运行结束后，缓存数据会丢失
```
**缓存生命周期说明：**
- `MemoryCache` 是纯内存缓存，数据存储在进程内存中
- 缓存数据仅在当前脚本运行期间有效
- 脚本运行结束后，所有缓存数据会丢失
#### 持久化缓存（PersistentCache）
持久化缓存支持跨进程/跨运行的缓存持久化，数据会保存到本地文件。支持多种存储后端，通过**工厂**按名称选择。
**安装可选依赖：**
```bash
pip install rquote[persistent]
# 或
uv pip install "rquote[persistent]"
```
**推荐：使用工厂创建（指定后端类型）**（`ttl` 单位为**秒**，默认 `None` 表示永久不过期）
```python
from rquote import get_price, create_persistent_cache
# 按后端名称创建，默认路径为 ~/.rquote/cache.{db|jsonl|pkl}
cache = create_persistent_cache(backend='sqlite')
cache = create_persistent_cache(backend='jsonl', path='/tmp/cache.jsonl') # 需过期可传 ttl=86400（秒）
# 使用缓存
sid, name, df = get_price('sh000001', dd=cache)
cache.close()
```
**兼容旧写法（不指定 backend 时）：**
```python
from rquote import get_price, PersistentCache
# 不传 backend 时默认用 sqlite；ttl 单位秒，默认 None 即永久不过期
cache = PersistentCache()
cache = PersistentCache(db_path='./my_cache.db')
sid, name, df = get_price('sh000001', dd=cache)
cache.close()
```
**持久化缓存特性：**
- ✅ 跨进程/跨运行持久化：数据保存在本地文件，下次运行仍可使用
- ✅ 智能数据合并：相同股票的数据会自动合并，key 不包含日期范围
- ✅ 智能扩展：当请求的日期范围超出缓存时，自动扩展并合并数据
- ✅ 支持 TTL：可设置缓存过期时间
- ✅ 多后端：sqlite / jsonl / pickle，均为标准库、无额外依赖，见下方选择维度
**后端选择维度**
| 维度 | sqlite | jsonl | pickle |
|------|--------|--------|--------|
| **依赖** | 标准库，无额外依赖 | 标准库，无额外依赖 | 标准库 |
| **内存占用** | 低（按需从文件读） | 低（按需从文件读） | 高（整库常驻内存） |
| **写入方式** | 单文件、随机写 | 单文件、整文件重写 | 单文件、整库序列化 |
| **适用场景** | 通用、嵌入式、内存紧张 | 通用、可读性好、内存紧张 | 兼容旧版、小数据量 |
**内存有限时的建议：**
- **优先使用 `sqlite` 或 `jsonl`**：两者都不会把整份缓存加载进内存，按 key 读写，适合本机内存紧张、树莓派或容器环境。
- 避免在内存紧张时使用 **`pickle`**：每次读写会整体加载/保存字典，数据量大时易 OOM。
## 主要功能
### 历史价格数据获取
#### `get_price(i, sdate='', edate='', freq='day', days=320, fq='qfq', dd=None)`
获取股票、基金、期货的历史价格数据
**参数:**
- `i`: 股票代码，使用新浪/腾讯的id形式
- `sdate`: 开始日期 (可选，格式：YYYY-MM-DD)
- `edate`: 结束日期 (可选，格式：YYYY-MM-DD)
- `freq`: 频率，默认'day' (日线)，可选：(港A)'week', 'month', (美股)'min'
- `days`: 获取天数，默认320天
- `fq`: 复权方式，默认'qfq' (前复权)，可选：'hfq' (后复权)
- `dd`: 本地缓存字典 (可选，已废弃，建议使用MemoryCache)
**代码格式说明:**
- A股: `sh000001`表示上证指数，`sz000001`表示深市000001股票`平安银行`
- ETF: `sh510050`表示上证50指数ETF
- 港股: `hk00700`表示港股腾讯
- 期货: 需加`fu`前缀，如`fuAP2110`，`fuBTC`表示比特币
- 美股: 需加对应交易所后缀，如`usBABA.N`，`usC.N`，`usAAPL.OQ`等
- 比特币：使用`fuBTC`代码
**示例:**
```python
from rquote import get_price
# 获取上证指数数据
sid, nm, df = get_price('sh000001')
print(df.head())
# 获取指定日期范围的数据
sid, nm, df = get_price('sz000001', sdate='2024-01-01', edate='2024-02-01')
# 获取比特币数据
sid, nm, df = get_price('fuBTC')
# 获取期货分钟数据
sid, nm, df = get_price('fuM2601', freq='min')
```
**返回数据格式:**
| date | open | close | high | low | vol |
|------------|---------|---------|---------|---------|------------|
| 2024-02-06 | 2680.48 | 2789.49 | 2802.93 | 2669.67 | 502849313 |
| 2024-02-07 | 2791.51 | 2829.70 | 2829.70 | 2770.53 | 547117439 |
#### `get_price_longer(i, l=2, edate='', freq='day', fq='qfq', dd=None)`
获取更长时间的历史数据，默认获取2年数据，并且参数与 `get_price` 保持一致
```python
from rquote import get_price_longer
# 获取3年的历史数据（默认日线、前复权，以最新交易日为结束）
sid, nm, df = get_price_longer('sh000001', l=3)
# 指定结束日期与频率（例如获取到 2024-02-01 的周线数据）
sid, nm, df = get_price_longer('sh000001', l=3, edate='2024-02-01', freq='week', fq='qfq')
```
### 股票列表获取
#### `get_cn_stock_list(money_min=2e8)`
获取A股股票列表，按成交额排序，默认筛选成交额大于2亿的股票
```python
from rquote import get_cn_stock_list
# 获取成交额大于5亿的股票列表
stocks = get_cn_stock_list(money_min=5e8)
# 返回格式: [{code, name, pe_ttm, volume, turnover/亿, ...}, ...]
```
#### `get_hk_stocks_500()`
获取港股前500只股票列表(按当日成交额排序)
```python
from rquote import get_hk_stocks_500
stocks = get_hk_stocks_500()
# 返回格式: [[code, name, price, -, -, -, -, volume, turnover, ...], ...]
```
#### `get_us_stocks(k=100)`
获取美股最大市值的k支股票列表
```python
from rquote import get_us_stocks
us_stocks = get_us_stocks(k=100) # 获取前100只
# 返回格式: [{name, symbol, market, mktcap, pe, ...}, ...]
```
#### `get_cnindex_stocks(index_type='hs300')`
获取中国指数成分股列表
```python
from rquote import get_cnindex_stocks
# 获取沪深300成分股
hs300_stocks = get_cnindex_stocks('hs300')
# 获取中证500成分股
zz500_stocks = get_cnindex_stocks('zz500')
# 获取中证1000成分股
zz1000_stocks = get_cnindex_stocks('zz1000')
# 返回格式: [{SECURITY_CODE, SECURITY_NAME_ABBR, INDUSTRY, WEIGHT, EPS, BPS, ROE, FREE_CAP, ...}, ...]
```
支持的指数类型：
- `'hs300'`: 沪深300
- `'sz50'`: 上证50
- `'zz500'`: 中证500
- `'kc500'`: 科创500
- `'zz1000'`: 中证1000
- `'zz2000'`: 中证2000
### 基金和期货
#### `get_cn_fund_list()`
获取A股ETF基金列表，按成交额排序
```python
from rquote import get_cn_fund_list
funds = get_cn_fund_list()
# 返回格式: [code, name, change, amount, price]
```
#### `get_cn_future_list()`
获取国内期货合约列表
```python
from rquote import get_cn_future_list
futures = get_cn_future_list()
# 返回格式: ['fuSC2109', 'fuRB2110', 'fuHC2110', ...]
```
### 板块和概念
#### `get_all_industries()`
获取所有行业板块列表
```python
from rquote import get_all_industries
industries = get_all_industries()
# 返回格式: [code, name, change, amount, price, sina_sw2_id]
```
#### `get_stock_concepts(i)`
获取指定股票所属的概念板块
```python
from rquote import get_stock_concepts
# 获取平安银行的概念板块
concepts = get_stock_concepts('sz000001')
# 返回概念代码列表，如 ['BK0420', 'BK0900', ...]
```
#### `get_stock_industry(i)`
获取指定股票所属的行业板块
```python
from rquote import get_stock_industry
# 获取平安银行的行业板块
industries = get_stock_industry('sz000001')
```
#### `get_industry_stocks(node)`
获取指定行业板块的股票列表
```python
from rquote import get_industry_stocks
# 获取行业板块股票
stocks = get_industry_stocks('sw2_480200')
```
### 实时行情
#### `get_tick(tgts=[])`
获取实时行情数据
```python
from rquote import get_tick
# 获取美股实时行情
tick_data = get_tick(['AAPL', 'GOOGL'])
# 返回格式: [{'name': 'Apple Inc', 'price': '150.25', 'price_change_rate': '1.2%', ...}]
```
### 可视化工具
#### `PlotUtils.plot_candle(i, sdate='', edate='', dsh=False, vol=True)`
绘制K线图
```python
from rquote import PlotUtils
import plotly.graph_objs as go
# 绘制平安银行的K线图
data, layout = PlotUtils.plot_candle('sz000001', sdate='2024-01-01', edate='2024-02-01')
# 使用plotly显示
fig = go.Figure(data=data, layout=layout)
fig.show()
```
## 高级功能
### 配置管理
```python
from rquote import config
# 使用默认配置
default_config = config.default_config
# 创建自定义配置
custom_config = config.Config(
http_timeout=15,
http_retry_times=5,
cache_enabled=True,
cache_ttl=7200 # 单位：秒
)
# 从环境变量创建配置
import os
os.environ['RQUOTE_HTTP_TIMEOUT'] = '20'
config_from_env = config.Config.from_env()
```
### 日志配置
**默认情况下，日志功能是关闭的。** 如果需要启用日志，可以通过环境变量手动开启：
#### 通过环境变量开启日志
```bash
# 设置日志级别为 INFO（会同时输出到文件和控制台）
export RQUOTE_LOG_LEVEL=INFO
# 可选：自定义日志文件路径（默认为 /tmp/rquote.log）
export RQUOTE_LOG_FILE=/path/to/your/logfile.log
# 然后运行你的Python脚本
python your_script.py
```
#### 支持的日志级别
- `DEBUG`: 详细的调试信息
- `INFO`: 一般信息（推荐）
- `WARNING`: 警告信息
- `ERROR`: 错误信息
- `CRITICAL`: 严重错误
#### 在Python代码中开启日志
```python
import os
# 在导入 rquote 之前设置环境变量
os.environ['RQUOTE_LOG_LEVEL'] = 'INFO'
os.environ['RQUOTE_LOG_FILE'] = '/tmp/rquote.log' # 可选
from rquote import get_price
# 现在日志已启用
sid, name, df = get_price('sh000001')
```
#### 关闭日志
如果不设置 `RQUOTE_LOG_LEVEL` 环境变量，或者设置为空值，日志功能将保持关闭状态（默认行为）。
### 使用改进的HTTP客户端
```python
from rquote.utils.http import HTTPClient
# 创建HTTP客户端
with HTTPClient(timeout=15, retry_times=3) as client:
response = client.get('https://example.com')
if response:
print(response.text)
```
### 使用缓存
```python
from rquote.cache import MemoryCache
# 创建缓存（ttl 单位：秒）
cache = MemoryCache(ttl=3600) # 缓存 1 小时
# 使用缓存
cache.put('key1', 'value1')
value = cache.get('key1')
cache.delete('key1')
cache.clear() # 清空所有缓存
```
### 异常处理
```python
from rquote import get_price
from rquote.exceptions import SymbolError, DataSourceError, NetworkError
try:
sid, name, df = get_price('invalid_symbol')
except SymbolError as e:
print(f"股票代码错误: {e}")
except DataSourceError as e:
print(f"数据源错误: {e}")
except NetworkError as e:
print(f"网络错误: {e}")
```
### 工具类
#### `WebUtils`
网络请求工具类
```python
from rquote import WebUtils
# 获取随机User-Agent
ua = WebUtils.ua()
# 获取请求头
headers = WebUtils.headers()
# 测试代理
result = WebUtils.test_proxy('127.0.0.1:8080')
```
#### `BasicFactors`
基础因子计算工具类
```python
from rquote import BasicFactors
import pandas as pd
# 假设df是价格数据DataFrame
# break_rise: 突破上涨
break_rise = BasicFactors.break_rise(df)
# min_resist: 最小阻力
min_resist = BasicFactors.min_resist(df)
# vol_extreme: 成交量极值
vol_extreme = BasicFactors.vol_extreme(df)
# bias_rate_over_ma60: 偏离MA60的比率
bias_rate = BasicFactors.bias_rate_over_ma60(df)
# op_ma: MA评分
ma_score = BasicFactors.op_ma(df)
```
## 架构改进
### 新版本改进
**v0.3.5** 主要改进：
1. **修复Critical Bugs**
- 修复了 `WebUtils.http_get` 中的 `cls.ua` bug
- 修复了 `test_proxy` 方法中的逻辑错误
- 改进了异常处理
2. **新增模块化架构**
- 配置管理模块 (`config.py`)
- 异常处理体系 (`exceptions.py`)
- 缓存抽象层 (`cache/`)
- 数据源抽象层 (`data_sources/`)
- 改进的HTTP客户端 (`utils/http.py`)
3. **向后兼容**
- 所有原有API保持不变
- 新增功能为可选使用
### 目录结构
```
rquote/
├── __init__.py # 公共API导出
├── config.py # 配置管理
├── exceptions.py # 异常定义
├── main.py # 主要功能（向后兼容）
├── utils.py # 工具类（向后兼容）
├── plots.py # 绘图工具
├── cache/ # 缓存模块
│ ├── __init__.py
│ ├── base.py # 缓存基类
│ └── memory.py # 内存缓存实现
├── data_sources/ # 数据源模块
│ ├── __init__.py
│ ├── base.py # 数据源基类
│ ├── sina.py # 新浪数据源
│ └── tencent.py # 腾讯数据源
├── parsers/ # 数据解析模块
│ ├── __init__.py
│ └── kline.py # K线数据解析
└── utils/ # 工具模块
├── __init__.py
├── http.py # HTTP客户端
└── date.py # 日期工具
```
## 测试
运行单元测试：
```bash
# 运行所有测试
python -m pytest tests/
# 运行特定测试
python -m pytest tests/test_utils.py
python -m pytest tests/test_cache.py
python -m pytest tests/test_config.py
python -m pytest tests/test_exceptions.py
python -m pytest tests/test_api.py
```
## 注意事项
1. **数据来源**: 数据来源于新浪财经、腾讯财经、东方财富等公开数据源
2. **请求频率**: 建议合理控制请求频率，避免被限制访问
3. **代码格式**:
- 期货代码需要加`fu`前缀，如`fuAP2110`
- 美股代码需要加对应后缀，如`usAAPL.OQ` （OQ->NASDAQ, N->NYSE, AM->ETF）
4. **网络要求**: 部分功能需要网络连接，请确保网络畅通
5. **缓存使用**: 建议使用缓存机制减少网络请求，提升性能
## 贡献
欢迎提交Issue和Pull Request！
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.9.0 | [] | [] | [] | [
"build>=0.9.0",
"httpx>=0.20.0",
"pandas>=1.0.0",
"setuptools>=42",
"twine>=3.8.0"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.10 | 2026-02-20T14:15:19.494676 | rquote-0.5.9.tar.gz | 49,490 | f9/82/e7db44f588ec82bf1c6da4f03ed51eb102c68f14d0b82bfa3aae67d52e1d/rquote-0.5.9.tar.gz | source | sdist | null | false | e83c7c0c18e5b22bac38c740c902addb | dfabda451fba2445f3752dd23999e6f6bd6f26a3360d83941a0fc528df0b8d1d | f982e7db44f588ec82bf1c6da4f03ed51eb102c68f14d0b82bfa3aae67d52e1d | null | [] | 212 |
2.4 | MachSysS | 0.10.0 | Machinery System Structure for interface | # MachSysS - Machinery System Structure
[](https://badge.fury.io/py/MachSysS)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/Apache-2.0)
`MachSysS` provides Protocol Buffer definitions, data structures, and conversion utilities for the FEEMS ecosystem. It enables standardized data exchange, serialization, and interoperability across different tools and programming languages.
## Features
### 🔄 Data Exchange
- **Protocol Buffer Schemas**: Well-defined data structures for machinery systems
- **Language Independence**: Use in Python, C++, Java, Go, and more
- **Version Control Friendly**: Text-based proto definitions
- **Compact Binary Format**: Efficient storage and transmission
### 🔧 Conversion Utilities
- **FEEMS ↔ Protobuf**: Bidirectional conversion between FEEMS objects and protobuf messages
- **Result Serialization**: Save simulation results for analysis and reporting
- **System Configuration**: Load/save complete system configurations
- **Time-Series Data**: Handle time-series results with pandas integration
### 📊 Data Structures
- **System Configuration**: Complete machinery system layout
- **Component Specifications**: Engines, generators, converters, loads
- **Simulation Results**: Fuel consumption, emissions, energy flows
- **Time-Series Profiles**: Operational data over time
## Installation
### From PyPI
```bash
pip install MachSysS
```
### From Source (Developers)
```bash
# Clone repository
git clone https://github.com/SINTEF/FEEMS.git
cd FEEMS
# Install with uv (recommended)
uv sync
# Or with pip
pip install -e machinery-system-structure/
```
## Quick Start
### Save a FEEMS System to Protobuf
```python
from feems.system_model import ElectricPowerSystem
from MachSysS.convert_to_protobuf import convert_electric_system_to_protobuf_machinery_system
# Create or load a FEEMS system
system = ElectricPowerSystem(...)
# Convert to protobuf
system_pb = convert_electric_system_to_protobuf_machinery_system(system)
# Save to file
with open("system_config.pb", "wb") as f:
f.write(system_pb.SerializeToString())
```
### Load a System from Protobuf
```python
from MachSysS.system_structure_pb2 import MachinerySystem
from MachSysS.convert_to_feems import convert_proto_propulsion_system_to_feems
# Load from file
with open("system_config.pb", "rb") as f:
system_pb = MachinerySystem()
system_pb.ParseFromString(f.read())
# Convert to FEEMS system
feems_system = convert_proto_propulsion_system_to_feems(system_pb)
# Use with FEEMS
feems_system.do_power_balance_calculation()
```
### Save Simulation Results
```python
from MachSysS.convert_feems_result_to_proto import convert_feems_result_to_proto
# Run simulation
result = system.get_fuel_energy_consumption_running_time()
# Convert results to protobuf
result_pb = convert_feems_result_to_proto(result, system)
# Save to file
with open("simulation_results.pb", "wb") as f:
f.write(result_pb.SerializeToString())
```
### Convert Results to Pandas DataFrames
```python
from MachSysS.convert_proto_timeseries import convert_proto_power_timeseries_to_df
# Load results
from MachSysS.feems_result_pb2 import FeemsResult
with open("simulation_results.pb", "rb") as f:
result_pb = FeemsResult()
result_pb.ParseFromString(f.read())
# Convert to DataFrame
df = convert_proto_power_timeseries_to_df(result_pb.power_timeseries)
# Analyze with pandas
print(df.describe())
df.plot()
```
## Protocol Buffer Schemas
### System Structure (`system_structure.proto`)
Defines the complete machinery system configuration:
```protobuf
message MachinerySystem {
string name = 1;
repeated Component components = 2;
repeated Connection connections = 3;
repeated Switchboard switchboards = 4;
repeated BusTieBreaker bus_tie_breakers = 5;
}
message Component {
string id = 1;
string name = 2;
ComponentType type = 3;
double rated_power_kw = 4;
double rated_speed_rpm = 5;
PerformanceCurve performance_curve = 6;
// ...
}
```
### Simulation Results (`feems_result.proto`)
Stores simulation outputs:
```protobuf
message FeemsResult {
string system_id = 1;
double duration_s = 2;
FuelConsumption total_fuel_consumption = 3;
Emissions total_emissions = 4;
EnergyConsumption energy_consumption = 5;
repeated ComponentResult component_results = 6;
PowerTimeSeries power_timeseries = 7;
}
```
### Time-Series Data (`gymir_result.proto`)
Alternative format for time-series results:
```protobuf
message PowerTimeSeries {
repeated double timestamp_s = 1;
map<string, PowerProfile> component_powers = 2;
}
message PowerProfile {
repeated double power_kw = 1;
repeated double efficiency = 2;
}
```
## Conversion API
### System Conversion
#### FEEMS → Protobuf
```python
from MachSysS.convert_to_protobuf import (
convert_electric_system_to_protobuf_machinery_system,
convert_component_to_protobuf
)
# Convert complete system
system_pb = convert_electric_system_to_protobuf_machinery_system(feems_system)
# Convert individual component
component_pb = convert_component_to_protobuf(genset)
```
#### Protobuf → FEEMS
```python
from MachSysS.convert_to_feems import (
convert_proto_propulsion_system_to_feems,
convert_proto_component_to_feems
)
# Convert complete system
feems_system = convert_proto_propulsion_system_to_feems(system_pb)
# Convert individual component
component = convert_proto_component_to_feems(component_pb)
```
### Results Conversion
```python
from MachSysS.convert_feems_result_to_proto import (
convert_feems_result_to_proto,
convert_fuel_consumption_to_proto,
convert_emissions_to_proto
)
# Convert complete result
result_pb = convert_feems_result_to_proto(feems_result, system)
# Convert individual metrics
fuel_pb = convert_fuel_consumption_to_proto(fuel_consumption)
emissions_pb = convert_emissions_to_proto(emissions)
```
### Time-Series Conversion
```python
from MachSysS.convert_proto_timeseries import (
convert_proto_power_timeseries_to_df,
convert_df_to_proto_power_timeseries
)
# Protobuf → DataFrame
df = convert_proto_power_timeseries_to_df(power_timeseries_pb)
# DataFrame → Protobuf
power_timeseries_pb = convert_df_to_proto_power_timeseries(df)
```
## Use Cases
### 1. Data Archiving
- Save system configurations for version control
- Archive simulation results for compliance
- Store reference designs
### 2. Tool Integration
- Exchange data with other simulation tools
- Import/export to CAD software
- Connect to databases
### 3. API Development
- Build REST APIs with protobuf serialization
- gRPC services for remote simulation
- Microservices architecture
### 4. Cross-Language Support
- Python simulation, C++ visualization
- Java backend, Python frontend
- Go microservices with Python analysis
### 5. Reporting
- Generate standardized reports
- Export to business intelligence tools
- Regulatory compliance submissions
## Package Structure
```
machinery-system-structure/
├── MachSysS/
│ ├── __init__.py
│ ├── system_structure_pb2.py # Generated from .proto
│ ├── system_structure_pb2.pyi # Type stubs
│ ├── feems_result_pb2.py # Generated from .proto
│ ├── gymir_result_pb2.py # Generated from .proto
│ ├── convert_to_protobuf.py # FEEMS → Protobuf
│ ├── convert_to_feems.py # Protobuf → FEEMS
│ ├── convert_feems_result_to_proto.py
│ └── convert_proto_timeseries.py
├── proto/
│ ├── system_structure.proto
│ ├── feems_result.proto
│ └── gymir_result.proto
├── tests/
├── compile_proto.sh # Protobuf compilation script
└── README.md
```
## Development
### Prerequisites
- Python ≥ 3.10
- Protocol Buffer compiler (`protoc`) for regenerating Python bindings
#### Install protoc
**macOS:**
```bash
brew install protobuf
```
**Ubuntu/Debian:**
```bash
apt-get install protobuf-compiler
```
**Windows:**
Download from [GitHub Releases](https://github.com/protocolbuffers/protobuf/releases)
### Workspace Setup
```bash
# Clone and sync
git clone https://github.com/SINTEF/FEEMS.git
cd FEEMS
uv sync
```
### Regenerating Protobuf Files
When you modify `.proto` files:
```bash
cd machinery-system-structure
./compile_proto.sh
```
This script:
1. Compiles `.proto` files to Python
2. Generates type stubs (`.pyi` files)
3. Fixes imports for relative module references
**Manual compilation:**
```bash
cd machinery-system-structure
protoc -I=proto --python_out=MachSysS proto/*.proto --pyi_out=MachSysS
```
### Running Tests
```bash
# All tests
uv run pytest machinery-system-structure/tests/
# Specific test file
uv run pytest machinery-system-structure/tests/test_convert_to_protobuf.py
# With coverage
uv run pytest --cov=MachSysS machinery-system-structure/tests/
```
### Code Quality
```bash
# Linting
uv run ruff check machinery-system-structure/
# Formatting
uv run ruff format machinery-system-structure/
```
## Requirements
- Python ≥ 3.10
- protobuf >= 5.29.6, < 6
- feems (for conversion utilities)
- pandas (for time-series conversion)
## Related Packages
- **feems**: Core FEEMS library for marine power system modeling
- **RunFeemsSim**: High-level simulation interface with PMS logic
## Contributing
Contributions welcome! See `CONTRIBUTING.md` for guidelines.
When adding new proto definitions:
1. Edit `.proto` files in `proto/`
2. Run `./compile_proto.sh`
3. Add conversion utilities in `MachSysS/`
4. Write tests in `tests/`
5. Update documentation
## License
Licensed under the Apache License 2.0 - see LICENSE file for details.
## Citation
```bibtex
@software{machsyss2024,
title = {MachSysS: Machinery System Structure},
author = {Yum, Kevin Koosup and contributors},
year = {2024},
url = {https://github.com/SINTEF/FEEMS}
}
```
## Support
- **Issues**: [GitHub Issues](https://github.com/SINTEF/FEEMS/issues)
- **Documentation**: [https://keviny.github.io/MachSysS/](https://keviny.github.io/MachSysS/)
- **Email**: kevinkoosup.yum@sintef.no
## Acknowledgments
Developed by SINTEF Ocean as part of the FEEMS ecosystem for standardized marine power system data exchange.
| text/markdown | null | Kevin Koosup Yum <kevinkoosup.yum@gmail.com> | null | null | null | FEEMS, protobuf, system, structure | [
"Natural Language :: English",
"Intended Audience :: Developers",
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"protobuf<6,>=5.29.6",
"feems"
] | [] | [] | [] | [
"Repository, https://github.com/SINTEF/FEEMS",
"Documentation, https://keviny.github.io/MachSysS/"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:14:58.668749 | machsyss-0.10.0.tar.gz | 39,093 | 6a/ba/27b17ece474b17e21459f5a851fd3935e312536dde345942f24475f28f9f/machsyss-0.10.0.tar.gz | source | sdist | null | false | 45cfa767d40ba83319978c713d2c50b4 | 8e824d73ac2721913bc9d5f6463401c54f8c67bde6cdd1dc794b2985fa06e250 | 6aba27b17ece474b17e21459f5a851fd3935e312536dde345942f24475f28f9f | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | pymrf4 | 0.1.2 | Yet another proxy server | # pymrf4
## To test with `curl`
```bash
# client resolves the domain name, ATYP_IPV4(1)
curl --socks5 socks5://127.0.0.1:9050 http://www.baidu.com
# Or let the proxy resolve the domain name, ATYP_DOMAINNAME(3)
curl --socks5 socks5h://127.0.0.1:9050 http://www.baidu.com
```
## Install as a Windows service
With nssm:
```bat
nssm install pymrf4 D:\Python312\python.exe
nssm set pymrf4 AppParameters "-m pymrf4"
nssm set pymrf4 AppDirectory C:\pymrf4
nssm set pymrf4 AppExit Default Restart
nssm set pymrf4 AppStdout C:\pymrf4\logs\service-err.log
nssm set pymrf4 AppStderr C:\pymrf4\logs\service-err.log
nssm set pymrf4 DisplayName pymrf4
nssm set pymrf4 ObjectName LocalSystem
nssm set pymrf4 Start SERVICE_AUTO_START
nssm set pymrf4 Type SERVICE_WIN32_OWN_PROCESS
``` | text/markdown | null | null | null | null | MIT License Copyright (c) 2023 Guo Xinghua Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"bcoding>=1.5",
"flask>=2.3",
"numpy>=2.0",
"peewee>=3.17",
"pyyaml>=6.0",
"requests>=2.31",
"smbprotocol>=1.15"
] | [] | [] | [] | [] | uv/0.6.5 | 2026-02-20T14:14:49.420058 | pymrf4-0.1.2.tar.gz | 206,471 | b3/e4/3c0fa054dfa03751cb5101a232b4ca5255419ae5111d373b2297d2e84dd9/pymrf4-0.1.2.tar.gz | source | sdist | null | false | a3942f92838cdfa260263aa04dd949b4 | 439814604e4dd4462edabd40223ccd9f77272bfa6aa3fa4411be841dd683737d | b3e43c0fa054dfa03751cb5101a232b4ca5255419ae5111d373b2297d2e84dd9 | null | [
"LICENSE"
] | 204 |
2.4 | polars-readstat | 0.12.3 | Read SAS (sas7bdat), Stata (dta), and SPSS (sav) files with polars | # polars_readstat
Polars plugin for SAS (`.sas7bdat`), Stata (`.dta`), and SPSS (`.sav`/`.zsav`) files.
The Python package wraps the Rust core in `polars_readstat_rs` and exposes a simple Polars-first API. I have tried to make sure there are no errors or regressions in this release (tested against 178 test files from pandas, pyreadstat, etc.).
The new rust engine is on par or faster than the old for many files, but it's not always faster (at least for SAS data sets), so if it's slower or I missed a bug, you can find info on the [prior version](https://github.com/jrothbaum/polars_readstat/tree/250f516a4424fbbe84c931a41cb82b454c5ca205) and install version 0.11.1 from pypi.
## Why use this?
- In project benchmarks, the new Rust-backed engine is typically faster than pandas/pyreadstat on large SAS/Stata files, especially for subset/filter workloads.
- It avoids the older C/C++ toolchain complexity and ships as standard Python wheels.
- API is Polars-first (`scan_readstat`, `read_readstat`, `write_readstat`).
## Install
```bash
pip install polars-readstat
```
## Core API
### 1) Lazy scan
```python
import polars as pl
from polars_readstat import scan_readstat
lf = scan_readstat("/path/file.sas7bdat", preserve_order=True)
df = lf.select(["SERIALNO", "AGEP"]).filter(pl.col("AGEP") >= 18).collect()
```
### 2) Eager read
```python
from polars_readstat import read_readstat
df = read_readstat("/path/file.dta")
```
### 3) Metadata + schema
```python
from polars_readstat import ScanReadstat
reader = ScanReadstat(path="/path/file.sav")
schema = reader.schema
metadata = reader.metadata
```
### 4) Write (Stata/SPSS) - ***EXPERIMENTAL***
I can test reading the data back with Stata, as I have access to it, but I don't have access to SPSS. I can make sure my code roundtrips properly and I'll be adding read tests from other packages (pyreadstat and pandas) to make sure they can read the files I create, but I'll need help testing things from others before I'm comfortable with the SPSS code.
```python
from polars_readstat import write_readstat
write_readstat(df, "/path/out.dta", threads=8)
write_readstat(df, "/path/out.sav")
```
`write_readstat` supports Stata (`dta`) and SPSS (`sav`). SAS writing is not supported.
## Tests run
We’ve tried to test this thoroughly:
- Cross-library comparisons on the pyreadstat and pandas test data, checking results against `polars-readstat==0.11.1`, [pyreadstat](https://github.com/Roche/pyreadstat), and [pandas](https://github.com/pandas-dev/pandas).
- Stata/SPSS read/write roundtrip tests.
- Large-file read/write benchmark runs on real-world data (results below).
If you want to run the same checks locally, helper scripts and tests are in `scripts/` and `tests/`.
## Benchmark
For each file, I compared 4 different scenarios: 1) load the full file, 2) load a subset of columns (Subset:True), 3) filter to a subet of rows (Filter: True), 4) load a subset of columns and filter to a subset of rows (Subset:True, Filter: True).
Benchmark context:
- Machine: AMD Ryzen 7 8845HS (16 cores), 14 GiB RAM, Linux Mint 22
- Storage: external SSD
- Last run: August 31, 2025
- Version tested: `polars-readstat` 0.12 (new Rust engine) against polars-readstat 0.11.1 (prior C++ and C engines) and pandas and pyreadstat
- Method: wall-clock timings via Python `time.time()`
### Compared to Pandas and Pyreadstat (using read_file_multiprocessing for parallel processing in Pyreadstat)
#### SAS
all times in seconds (speedup relative to pandas in parenthesis below each)
| Library | Full File | Subset: True | Filter: True | Subset: True, Filter: True |
|---------|------------------------------|-----------------------------|-----------------------------|----------------------------|
| polars_readstat<br>[New rust engine](https://github.com/jrothbaum/polars_readstat_rs) | 0.90<br>(2.3×) | 0.07<br>(29.4×) | 1.23<br>(2.5×) | 0.07<br>(29.9×) |
| polars_readstat<br>engine="cpp"<br>(fastest for 0.11.1) | 1.31<br>(1.6×) | 0.09<br>(22.9×) | 1.56<br>(1.9×) | 0.09<br>(23.2×) |
| pandas | 2.07 | 2.06 | 3.03 | 2.09 |
| pyreadstat | 10.75<br>(0.2×) | 0.46<br>(4.5×) | 11.93<br>(0.3×) | 0.50<br>(4.2×) |
#### Stata
all times in seconds (speedup relative to pandas in parenthesis below each)
| Library | Full File | Subset: True | Filter: True | Subset: True, Filter: True |
|---------|------------------------------|-----------------------------|-----------------------------|----------------------------|
| polars_readstat<br>[New rust engine](https://github.com/jrothbaum/polars_readstat_rs) | 0.17<br>(6.7×) | 0.12<br>(9.8×) | 0.24<br>(4.1×) | 0.11<br>(8.7×) |
| polars_readstat<br>engine="readstat"<br>(the only option for 0.11.1) | 1.80<br>(0.6×) | 0.27<br>(4.4×) | 1.31<br>(0.8×) | 0.29<br>(3.3×) |
| pandas | 1.14 | 1.18 | 0.99 | 0.96 |
| pyreadstat | 7.46<br>(0.2×) | 2.18<br>(0.5×) | 7.66<br>(0.1×) | 2.24<br>(0.4×) |
Detailed benchmark notes and dataset descriptions are in `BENCHMARKS.md`.
| text/markdown; charset=UTF-8; variant=GFM | null | Jon Rothbaum <jlrothbaum@gmail.com> | null | null | MIT | null | [
"Programming Language :: Rust",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"polars>=1.25.2"
] | [] | [] | [] | [
"Bug-Tracker, https://github.com/jrothbaum/polars_readstat/issues",
"Homepage, https://github.com/jrothbaum/polars_readstat",
"Repository, https://github.com/jrothbaum/polars_readstat"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:13:51.964894 | polars_readstat-0.12.3-cp39-abi3-win_amd64.whl | 20,527,345 | dc/82/5ed4696708d030bd79709c7e75e66037300cd90afccb99546473e42fc9dc/polars_readstat-0.12.3-cp39-abi3-win_amd64.whl | cp39 | bdist_wheel | null | false | 6277dd34a1d08f5cef6d2bb6a3006776 | 6152a427f24bbf2397aa58209e4a72cf04a6aede0b37f463ba1a866db5496767 | dc825ed4696708d030bd79709c7e75e66037300cd90afccb99546473e42fc9dc | null | [
"LICENSE"
] | 376 |
2.4 | charter-governance | 0.8.0 | AI governance layer. Local-first. Open source. Three layers: hard constraints, gradient decisions, self-audit. | # Charter
AI governance layer. Local-first. Open source.
Three layers: hard constraints, gradient decisions, self-audit.
## Install
```
pip install charter-governance
```
## Quick Start
```bash
charter init # Create governance config + identity
charter generate # Generate a CLAUDE.md with your rules
charter generate --format system-prompt # Or a system prompt for any AI
charter audit # Run a governance audit
charter status # See everything at a glance
```
## What It Does
Charter creates a governance framework for your AI. You define the rules. The AI follows them. The system audits itself.
**Layer A: Hard Constraints.** Things your AI must never do. No exceptions.
**Layer B: Gradient Decisions.** Actions that require human judgment above certain thresholds.
**Layer C: Self-Audit.** The system reviews what it did and reports honestly.
## Domain Templates
Charter ships with governance presets for:
- Healthcare (HIPAA-aware, clinical safety)
- Finance (compliance-focused, transaction controls)
- Education (FERPA-aware, student protection)
- General (universal governance baseline)
## Identity
Charter creates a pseudonymous identity backed by a hash chain. Every action is signed and recorded. When you're ready, link your real identity and all prior work transfers to you. The chain is the proof.
```bash
charter identity # View your identity
charter identity verify # Link real identity (authorship transfer)
charter identity proof # Generate a signed transfer proof
```
## Contexts
Separate work and personal knowledge with governed boundaries.
```bash
charter context create personal
charter context create work --type work --org "Your Org" --email you@org.com
charter context bridge personal --target work --policy read-only
charter context approve <bridge_id> # Both parties must consent
charter context revoke <bridge_id> # Either party can revoke
```
Knowledge does not flow between contexts by default. Bridging requires explicit consent from both sides.
## Identity Verification
Upgrade your pseudonymous identity with government ID verification via Persona or ID.me.
```bash
charter verify configure persona # Set up Persona API credentials
charter verify start # Open browser for ID verification
charter verify check <inquiry_id> # Check verification status
charter verify status # See configured providers
```
Free tier: 500 verifications per month via Persona. No credit card required.
## Network
Connect to the network. Register your expertise. Record contributions.
```bash
charter connect init # Create your node
charter connect source "My Data" shopify # Register data sources
charter connect contribute "Title" governance # Record contributions
charter connect formation "Name" # Recognize who shaped you
```
## MCP Server
Charter runs as an MCP (Model Context Protocol) server. Any AI model that supports MCP gets Charter governance.
```bash
pip install charter-governance[mcp]
# Local (Claude Code via .mcp.json)
charter mcp-serve --transport stdio
# Remote (Mac Mini, Grok via remote MCP)
charter mcp-serve --transport sse --port 8375
```
10 tools exposed: `charter_status`, `charter_stamp`, `charter_verify_stamp`, `charter_append_chain`, `charter_read_chain`, `charter_check_integrity`, `charter_get_config`, `charter_identity`, `charter_audit`, `charter_local_inference`.
Every action logged to an immutable hash chain. Same governance, any model.
## Philosophy
The value of AI is not in the tokens. Tokens are going to zero. The value is in the humans who provide judgment, context, and ethics. Charter is the governance layer that makes human judgment enforceable on AI systems.
Open source because we don't need more rent seekers. We need human creativity to thrive while being accountable for what it creates.
## License
Apache 2.0
| text/markdown | null | GermPharm LLC <mmaughan@germpharm.org> | null | null | null | ai, governance, ethics, audit, mcp | [
"Development Status :: 4 - Beta",
"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 :: Quality Assurance",
"Topic :: System :: Systems Administration",
"Intended Audience :: Developers",
"Environment :: Console"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"pyyaml>=6.0",
"mcp>=1.0; extra == \"mcp\"",
"uvicorn>=0.30; extra == \"mcp\"",
"starlette>=0.40; extra == \"mcp\"",
"flask>=3.0; extra == \"daemon\"",
"psutil>=5.9; extra == \"daemon\"",
"pytest>=7.0; extra == \"test\""
] | [] | [] | [] | [
"Homepage, https://github.com/germpharm/charter",
"Issues, https://github.com/germpharm/charter/issues",
"Documentation, https://github.com/germpharm/charter#readme"
] | twine/6.2.0 CPython/3.13.0 | 2026-02-20T14:12:52.030947 | charter_governance-0.8.0.tar.gz | 71,418 | a4/f6/d5fbe2863748cfc249b161783e443cd2e81f13498f6a4e8fc5dab3200326/charter_governance-0.8.0.tar.gz | source | sdist | null | false | c3ffeb4c66f9321bd1fdae97c7eac1e4 | 86bdbb937ac7e8158798952b1dce2289f232debe1afafa5f3d7b885331c56999 | a4f6d5fbe2863748cfc249b161783e443cd2e81f13498f6a4e8fc5dab3200326 | Apache-2.0 | [
"LICENSE"
] | 222 |
2.4 | worai | 4.1.1 | AI-powered CLI for WordLift knowledge graph and SEO workflows. | # worai
Command-line toolkit for WordLift operations and SEO checks.
Pronunciation: "waw-RYE"
Docs: https://docs.wordlift.io/worai/
## Install
- `pipx install worai`
- `pip install worai`
Full docs: https://docs.wordlift.io/worai/
Runtime dependency note:
- `wordlift-sdk>=5.0.0,<6.0.0` (installed automatically by pip)
- `copier` (required by `worai graph sync create`, installed automatically by pip)
If you plan to run `seocheck`, install Playwright browsers:
- `playwright install chromium`
## Quick Start
- `worai --help`
- `worai seocheck https://example.com/sitemap.xml`
- `worai google-search-console --site sc-domain:example.com --client-secrets ./client_secrets.json`
- `worai <command> --help`
## Configuration
Config file (TOML) discovery order:
- `--config`
- `WORAI_CONFIG`
- `./worai.toml`
- `~/.config/worai/config.toml`
- `~/.worai.toml`
Profiles:
- `[profile.<name>]` with `--profile` or `WORAI_PROFILE`
Common keys:
- `wordlift.api_key`
- `gsc.id`
- `gsc.client_secrets`
- `ga.id`
- `ga.client_secrets`
- `oauth.token` (shared token for GSC + GA)
- `postprocessor_runtime` (graph sync runtime: `subprocess` or `persistent`; profile override supported)
- `ingest.source` (`auto|urls|sitemap|sheets|local`)
- `ingest.loader` (`auto|simple|proxy|playwright|premium_scraper|web_scrape_api|passthrough`)
- `ingest.passthrough_when_html` (default: `true`)
Supported environment variables:
- `WORAI_CONFIG` — path to a config TOML file (overrides discovery order).
- `WORAI_PROFILE` — profile name under `[profile.<name>]`.
- `WORAI_LOG_LEVEL` — default log level (`debug|info|warning|error`).
- `WORAI_LOG_FORMAT` — default log format (`text|json`).
- `WORDLIFT_KEY` — WordLift API key for entity operations.
- `WORDLIFT_API_KEY` — alternate WordLift API key name (also accepted by some commands).
- `GSC_CLIENT_SECRETS` — path to OAuth client secrets JSON for GSC.
- `GSC_ID` — GSC property URL.
- `OAUTH_TOKEN` — path to store the shared OAuth token (GSC + GA).
- `GSC_OUTPUT` — default output CSV path for GSC export.
- `GA_ID` — GA4 property ID for Analytics sections.
- `GA_CLIENT_SECRETS` — path to OAuth client secrets JSON for GA4.
- `GSC_TOKEN` / `GA_TOKEN` — legacy aliases for `OAUTH_TOKEN` (must point to the same file if used).
- `WORAI_DISABLE_UPDATE_CHECK` — set to `1|true|yes|on` to disable startup update checks.
`.env` support:
- `worai` loads `.env` from the current working directory (and parent lookup) at startup.
- values from `.env` are treated as environment variables.
- existing environment variables take precedence over `.env` values.
Example environment setup:
```
export WORDLIFT_KEY="wl_..."
export WORAI_CONFIG="~/worai.toml"
export WORAI_PROFILE="dev"
export GSC_CLIENT_SECRETS="~/client_secrets.json"
export OAUTH_TOKEN="~/oauth_token.json"
```
Example `worai.toml`:
```
[defaults]
log_level = "info"
[wordlift]
api_key = "wl_..."
[gsc]
id = "sc-domain:example.com"
client_secrets = "/path/to/client_secrets.json"
[ga]
id = "123456789"
client_secrets = "/path/to/client_secrets.json"
[oauth]
token = "/path/to/oauth_token.json"
[ingest]
source = "auto"
loader = "web_scrape_api"
passthrough_when_html = true
```
Ingestion profile examples:
```toml
[profile.inventory_local]
ingest.source = "local"
ingest.loader = "passthrough"
ingest.passthrough_when_html = true
[profile.inventory_remote]
ingest.source = "sitemap"
ingest.loader = "web_scrape_api"
[profile.graph_sync_proxy]
urls = ["https://example.com/a", "https://example.com/b"]
ingest.source = "urls"
ingest.loader = "proxy"
web_page_import_timeout = "60s"
```
## Commands
Full docs: https://docs.wordlift.io/worai/
- `seocheck` — run SEO checks for sitemap URLs and URL lists.
- `google-search-console` — export GSC page metrics as CSV.
- `dedupe` — deduplicate WordLift entities by schema:url.
- `canonicalize-duplicate-pages` — select canonical URLs using GSC KPIs.
- `delete-entities-from-csv` — delete entities listed in a CSV.
- `find-faq-page-wrong-type` — find and patch FAQPage typing issues.
- `find-missing-names` — find entities missing schema:name/headline.
- `find-url-by-type` — list schema:url values by type from RDF.
- `graph` — run graph-specific workflows.
- `link-groups` — build or apply LinkGroup data from CSV.
- `patch` — patch entities from RDF.
- `structured-data` — generate JSON-LD/YARRRML mappings or materialize RDF from YARRRML.
- `validate` — validate JSON-LD with SHACL shapes (use `structured-data validate page` for webpage URLs).
- `self update` — check for new worai versions and optionally run the upgrade command.
- `upload-entities-from-turtle` — upload .ttl files with resume.
- `dil-import` - upload DILs from a CSV file.
Command help:
- `worai <command> --help`
Autocompletion:
- `worai --install-completion`
- `worai --show-completion`
Updates:
- `worai` checks for new versions periodically and prints a non-blocking notice when an update is available.
- run `worai self update` to check manually and see/apply the suggested upgrade command.
## Examples
seocheck
- `worai seocheck https://example.com/sitemap.xml`
- `worai seocheck https://example.com/sitemap.xml --output-dir ./seocheck-report --save-html`
- `worai seocheck https://example.com/sitemap.xml --output-dir ./seocheck-report --no-open-report`
- `worai seocheck https://example.com/sitemap.xml --user-agent "Mozilla/5.0 ..."`
- `worai seocheck https://example.com/sitemap.xml --sitemap-fetch-mode browser`
- `worai seocheck https://example.com/sitemap.xml --no-report-ui`
- `worai seocheck https://example.com/sitemap.xml --recheck-failed --recheck-from ./seocheck-report`
google-search-console
- `worai google-search-console --site sc-domain:example.com --client-secrets ./client_secrets.json`
- Uses OAuth redirect port 8080 by default.
seoreport (with Analytics)
- `worai seoreport --site sc-domain:example.com --ga-id 123456789 --format html`
canonicalize-duplicate-pages
- `worai canonicalize-duplicate-pages --input gsc_pages.csv --output canonical_targets.csv --kpi-window 28d --kpi-metric clicks`
- `worai canonicalize-duplicate-pages --input gsc_pages.csv --entity-type Product`
dedupe
- `worai dedupe --dry-run`
find-faq-page-wrong-type
- `worai find-faq-page-wrong-type ./data.ttl --dry-run --replace-type`
- `worai find-faq-page-wrong-type ./data.ttl --patch --replace-type`
find-missing-names
- `worai find-missing-names ./data.ttl`
find-url-by-type
- `worai find-url-by-type ./data.ttl schema:Service schema:Product`
link-groups
- `worai link-groups ./links.csv --format turtle`
- `worai link-groups ./links.csv --apply --dry-run --concurrency 4`
graph
- `worai --config ./worai.toml graph sync run --profile acme`
- `worai graph sync run --profile acme --debug`
- `worai graph sync create ./acme-graph`
- `worai graph sync create ./acme-graph --template ./graph-sync-template --defaults`
- `worai graph sync create ./acme-graph --data-file ./answers.yml --non-interactive`
- `worai graph sync create ./acme-graph --vcs-ref v1.2.3`
- `worai graph property delete seovoc:html --dry-run`
- `worai graph property delete https://w3id.org/seovoc/html --yes --workers 4`
- `graph property delete` sends `X-include-Private: true` by default for both GraphQL match discovery and entity PATCH requests.
- `graph sync create` runs Copier in trusted mode by default so template `_tasks` execute.
- Mapping docs (for `[profile.<name>]`): `docs/graph-sync-mappings-reference.md`, `docs/graph-sync-mappings-guide.md`, `docs/graph-sync-mappings-examples.md`
- `web_page_import_timeout` is configured in seconds in `worai.toml` (`60` -> `60000` ms in SDK).
- `postprocessor_runtime = "persistent"` in `worai.toml` sets SDK env `POSTPROCESSOR_RUNTIME=persistent` for `graph sync run` (profile value overrides global).
- SDK `wordlift-sdk` 5.1.1+ postprocessor context migration:
- `context.settings` -> `context.profile` (for example `context.profile["settings"]["api_url"]`)
- `context.account.key` -> `context.account_key`
- `context.account` remains the clean `/me` account object
- SDK 5 ingestion defaults to `INGEST_LOADER=web_scrape_api`; legacy `web_page_import_mode=default` maps to `web_scrape_api`.
- `WEB_PAGE_IMPORT_MODE` is emitted as an SDK-valid fetch mode:
- `ingest.loader=proxy` -> `WEB_PAGE_IMPORT_MODE=proxy`
- `ingest.loader=premium_scraper` -> `WEB_PAGE_IMPORT_MODE=premium_scraper`
- `ingest.loader=web_scrape_api` (and other loaders) -> `WEB_PAGE_IMPORT_MODE=default`
patch
- `worai patch ./data.ttl --dry-run --add-types`
structured-data
- `worai structured-data create https://example.com/article Review --output-dir ./structured-data`
- `worai structured-data create https://example.com/article --type Review --output-dir ./structured-data`
- `worai structured-data create https://example.com/article --type Review --debug`
- `worai structured-data create https://example.com/article --type Review --max-xhtml-chars 40000 --max-nesting-depth 2`
- `worai structured-data generate https://example.com/sitemap.xml --yarrrml ./mapping.yarrrml --output-dir ./out`
- `worai structured-data generate https://example.com/page --yarrrml ./mapping.yarrrml --format jsonld`
- `worai structured-data inventory https://example.com/sitemap.xml --output ./structured-data-inventory.csv`
- `worai structured-data inventory ./urls.txt --output ./structured-data-inventory.csv`
- `worai structured-data inventory https://docs.google.com/spreadsheets/d/<id>/edit --sheet-name URLs_US --output ./structured-data-inventory.csv`
- `worai structured-data inventory https://example.com/sitemap.xml --destination-sheet-id <spreadsheet_id> --destination-sheet-name Inventory`
- `worai structured-data inventory https://example.com/sitemap.xml --output ./structured-data-inventory.csv --concurrency auto`
- `worai structured-data inventory /path/to/debug_cloud/us --source-type debug-cloud --output ./structured-data-inventory.csv`
- `worai structured-data inventory /path/to/debug_cloud/us --ingest-source local --ingest-loader passthrough --output ./structured-data-inventory.csv`
- `worai structured-data inventory https://example.com/sitemap.xml --ingest-loader web_scrape_api --output ./structured-data-inventory.csv`
validate
- `worai validate jsonld --shape review-snippet --shape schema-review ./data.jsonld`
- `worai validate jsonld --format raw https://api.wordlift.io/data/example.jsonld`
- `worai structured-data validate page https://example.com/article --shape review-snippet`
self update
- `worai self update --check-only`
- `worai self update --yes`
upload-entities-from-turtle
- `worai upload-entities-from-turtle ./entities --recursive --limit 50`
dil-import
- `worai dil-import <wordlift_key> <path_to_csv_file>`
## Troubleshooting
- Playwright missing browsers:
- `playwright install chromium`
- YARRRML conversion:
- `npm install -g @rmlio/yarrrml-parser`
- RML execution:
- `morph-kgc` is included in project dependencies
- Dependency notes:
- Common runtime libs (e.g., `requests`, `rdflib`, `tqdm`, `advertools`, Google auth helpers) are provided transitively by `wordlift-sdk`.
- OAuth token issues:
- Remove the token file and re-run `worai google-search-console`.
- If you are prompted to re-auth every run, delete the token file to force a new consent flow that includes a refresh token.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"copier<10.0.0,>=9.7.1",
"jinja2>=3.1.0",
"morph-kgc>=2.7.0",
"playwright>=1.48.0",
"python-dotenv>=1.0.0",
"pyshacl>=0.26.0",
"typer>=0.12.5",
"wordlift-sdk<6.0.0,>=5.1.1",
"pytest>=8.3.4; extra == \"dev\"",
"pytest-asyncio>=0.23.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:12:15.984686 | worai-4.1.1.tar.gz | 107,405 | 5e/93/b4208c7483a4cf0fad18e23190ba3be630157e40dab95b44afdc69e414ba/worai-4.1.1.tar.gz | source | sdist | null | false | bd20aa26353a9988c5a594b366660b79 | b40847b3fb3d5ae45f0ac151707f484cb6c8f0c3352dfffa4eb876d39e8375c9 | 5e93b4208c7483a4cf0fad18e23190ba3be630157e40dab95b44afdc69e414ba | null | [] | 217 |
2.4 | contree-mcp | 0.1.3 | MCP server for Contree container management system | # ConTree MCP Server
[](https://pypi.org/project/contree-mcp/)
[](https://github.com/nebius/contree-mcp/actions/workflows/tests.yml)
[](LICENSE)
Run code in isolated cloud containers. ConTree gives AI agents secure sandboxed execution environments with full root access, network, and persistent images.
## Why ConTree?
**Fearless experimentation.** Agents can:
- Run destructive commands (`rm -rf /`, `dd`, kernel exploits) - nothing escapes the sandbox
- Make mistakes freely - revert to any previous image UUID at zero cost
- Execute potentially dangerous user requests - ConTree IS the safe runtime for risky operations
- Break things on purpose - corrupt filesystems, crash kernels, test failure modes
Every container is isolated. Every image is immutable. Branching is cheap. Mistakes are free.
## Quick Setup
### 1. Get an API Token
Contree is in **Early Access**. To get an API token, fill out the request form at [contree.dev](https://contree.dev).
### 2. Create Config File
Store credentials in `~/.config/contree/mcp.ini`:
```ini
[DEFAULT]
url = https://contree.dev/
token = <TOKEN HERE>
```
### 3. Configure Your MCP Client
#### Claude Code
```bash
claude mcp add --transport stdio contree -- $(which uvx) contree-mcp
```
Restart Claude Code or run `/mcp` to verify.
#### OpenAI Codex CLI
Add to `~/.codex/config.toml`:
```toml
[mcp_servers.contree]
command = "uvx"
args = ["contree-mcp"]
```
#### Claude Desktop
Add to config file:
- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
```json
{"mcpServers": {"contree": {"command": "uvx", "args": ["contree-mcp"]}}}
```
> **Note:** You can alternatively pass credentials via environment variables (`CONTREE_MCP_TOKEN`, `CONTREE_MCP_URL`) in your MCP client config, but this is not recommended as tokens may appear in process listings.
## Manual Installation
```bash
# Using uv
uv pip install contree-mcp
# Using pip
pip install contree-mcp
# Run manually
contree-mcp --token YOUR_TOKEN
# HTTP mode (for network access)
contree-mcp --mode http --http-port 9452 --token YOUR_TOKEN
# Visit http://localhost:9452/ for interactive documentation with
# setup guides, tool reference, and best practices.
```
### Container Installation (Alpine/Ubuntu/Debian)
PEP 668 requires additional flags:
```bash
pip install --break-system-packages contree-mcp
uv pip install --break-system-packages --python /usr/bin/python3 contree-mcp
```
## Configuration
| Argument | Environment Variable | Default |
|----------|---------------------|---------|
| - | `CONTREE_MCP_CONFIG` | `~/.config/contree/mcp.ini` |
| `--token` | `CONTREE_MCP_TOKEN` | (required) |
| `--url` | `CONTREE_MCP_URL` | `https://contree.dev/` |
| `--mode` | `CONTREE_MCP_MODE` | `stdio` |
| `--http-port` | `CONTREE_MCP_HTTP_PORT` | `9452` |
| `--log-level` | `CONTREE_MCP_LOG_LEVEL` | `warning` |
## Available Tools
### Command Execution
| Tool | Description |
|------|-------------|
| `contree_run` | Execute command in container (spawns microVM). Supports `wait=false` for async execution. |
### Image Management
| Tool | Description |
|------|-------------|
| `contree_list_images` | List available container images |
| `contree_get_image` | Get image details by UUID or tag |
| `contree_import_image` | Import OCI image from registry (requires authentication) |
| `contree_registry_token_obtain` | Open browser to create PAT for registry authentication |
| `contree_registry_auth` | Validate and store registry credentials |
| `contree_set_tag` | Set or remove a tag for an image |
### File Transfer
| Tool | Description |
|------|-------------|
| `contree_upload` | Upload a file to ConTree for use in containers |
| `contree_download` | Download a file from a container image to local filesystem |
| `contree_rsync` | Sync local files to ConTree with caching and deduplication |
### Image Inspection
| Tool | Description |
|------|-------------|
| `contree_list_files` | List files and directories in an image (no VM needed) |
| `contree_read_file` | Read a file from an image (no VM needed) |
### Operations
| Tool | Description |
|------|-------------|
| `contree_list_operations` | List operations (running or completed) |
| `contree_get_operation` | Get operation status and result |
| `contree_wait_operations` | Wait for multiple async operations to complete |
| `contree_cancel_operation` | Cancel a running operation |
### Documentation
| Tool | Description |
|------|-------------|
| `contree_get_guide` | Get agent guide sections (workflow, quickstart, async, etc.) |
## Resource Templates
MCP resource templates expose image files and documentation directly via URIs. Fast operations, no VM required.
| Resource | URI Template | Description |
|----------|--------------|-------------|
| `contree_image_read` | `contree://image/{image}/read/{path}` | Read a file from an image |
| `contree_image_ls` | `contree://image/{image}/ls/{path}` | List directory in an image |
| `contree_image_lineage` | `contree://image/{image}/lineage` | View image parent-child relationships |
| `contree_guide` | `contree://guide/{section}` | Agent guide and best practices |
**URI Examples:**
- `contree://image/abc-123-uuid/read/etc/passwd` - Read file by image UUID
- `contree://image/tag:alpine:latest/read/etc/os-release` - Read file by tag
- `contree://image/abc-123-uuid/ls/.` - List root directory
- `contree://image/tag:python:3.11/ls/usr/local/lib` - List nested directory
- `contree://image/abc-123-uuid/lineage` - View image ancestry and children
- `contree://guide/reference` - Tool reference
- `contree://guide/quickstart` - Common workflow patterns
**Guide Sections:** `workflow`, `reference`, `quickstart`, `state`, `async`, `tagging`, `errors`
## Examples
### Prepare a Reusable Environment (Recommended First Step)
**Step 1: Check for existing environment**
```json
// contree_list_images
{"tag_prefix": "common/python-ml"}
```
**Step 2: If not found, build and tag it**
```json
// contree_import_image
{"registry_url": "docker://docker.io/python:3.11-slim"}
// contree_run (install packages)
{"command": "pip install numpy pandas scikit-learn", "image": "<result_image>", "disposable": false}
// contree_set_tag
{"image_uuid": "<result_image>", "tag": "common/python-ml/python:3.11-slim"}
```
**Step 3: Use the prepared environment**
```json
// contree_run
{"command": "python train_model.py", "image": "tag:common/python-ml/python:3.11-slim"}
```
### Run a command
**contree_run:**
```json
{"command": "python -c 'print(\"Hello from ConTree!\")'", "image": "tag:python:3.11"}
```
### Parallel Execution (Async Pattern)
Launch multiple instances simultaneously with `wait: false`, then poll for results:
**contree_run** (x3):
```json
{"command": "python experiment_a.py", "image": "tag:python:3.11", "wait": false}
{"command": "python experiment_b.py", "image": "tag:python:3.11", "wait": false}
{"command": "python experiment_c.py", "image": "tag:python:3.11", "wait": false}
```
Each returns immediately with `operation_id`. Poll with **contree_get_operation**:
```json
{"operation_id": "op-1"}
```
### Trie-like Exploration Tree
Build branching structures where results become new source images.
**contree_run** - create branch point with `disposable: false`:
```json
{"command": "pip install numpy pandas", "image": "tag:python:3.11", "disposable": false}
```
Returns `result_image: "img-with-deps"`.
**contree_run** - branch into parallel experiments:
```json
{"command": "python test_numpy.py", "image": "img-with-deps", "wait": false}
{"command": "python test_pandas.py", "image": "img-with-deps", "wait": false}
```
### Sync Local Files to Container
**contree_rsync** - sync a project directory:
```json
{
"source": "/path/to/project",
"destination": "/app",
"exclude": ["__pycache__", "*.pyc", ".git", "node_modules"]
}
```
Returns `directory_state_id: "ds_abc123"`.
**contree_run** - run with injected files:
```json
{
"command": "python /app/main.py",
"image": "tag:python:3.11",
"directory_state_id": "ds_abc123"
}
```
### List images
**contree_list_images:**
```json
{"tag_prefix": "python"}
```
### Read a file (Resource Template)
Use the `contree_image_file` resource template:
```
contree://image/tag:busybox:latest/read/etc/passwd
```
### Import an image
**Step 1: Authenticate with registry (first time only)**
```json
// contree_registry_token_obtain - opens browser for PAT creation
{"registry_url": "docker://docker.io/alpine:latest"}
// contree_registry_auth - validate and store credentials
{"registry_url": "docker://docker.io/alpine:latest", "username": "myuser", "token": "dckr_pat_xxx"}
```
**Step 2: Import the image**
```json
// contree_import_image
{"registry_url": "docker://docker.io/alpine:latest"}
```
To make it reusable, tag after importing:
```json
// contree_set_tag
{"image_uuid": "<result_image>", "tag": "common/base/alpine:latest"}
```
### Track Image Lineage
View parent-child relationships and navigate image history using the `contree_image_lineage` resource:
```
contree://image/abc-123-uuid/lineage
```
Returns:
```json
{
"image": "abc-123-uuid",
"parent": {"image": "parent-uuid", "command": "pip install numpy", "exit_code": 0},
"children": [{"image": "child-uuid", "command": "python test.py", ...}],
"ancestors": [/* parent chain up to root */],
"root": {"image": "root-uuid", "registry_url": "docker://python:3.11", "is_import": true},
"depth": 2,
"is_known": true
}
```
Use this to rollback to any ancestor or understand how an image was created.
### Download a build artifact
**contree_download:**
```json
{"image": "img-build-result", "path": "/app/dist/binary", "destination": "./binary", "executable": true}
```
## Dependencies
- `mcp` - Model Context Protocol SDK
- `httpx` - Async HTTP client
- `argclass` - Argument parsing
- `aiosqlite` - Async SQLite database
- `pydantic` - Data validation
## Development
**Requirements:** Python 3.10+
```bash
# Clone and install in dev mode
git clone https://github.com/nebius/contree-mcp.git
cd contree-mcp
uv sync --group dev
```
### Development Workflow
Follow this sequence when making changes:
1. **Make code changes** - Edit files in `contree_mcp/`
2. **Run tests** - Ensure all tests pass
```bash
uv run pytest tests/ -v
```
3. **Run linter** - Fix any style issues
```bash
uv run ruff check contree_mcp
uv run ruff format contree_mcp # Auto-fix formatting
```
4. **Type check** (optional but recommended)
```bash
uv run mypy contree_mcp
```
5. **Update documentation** - Keep docs in sync with code
- `README.md` - User-facing docs, examples, tool descriptions
- `llm.txt` - Shared context for AI agents (architecture, class hierarchy, internals)
### Quick Commands
```bash
# Full validation cycle
uv run pytest tests/ -q && uv run ruff check contree_mcp && echo "All checks passed"
# Run specific test file
uv run pytest tests/test_tools/test_run.py -v
# Auto-fix linting issues
uv run ruff check contree_mcp --fix
```
### Testing GitHub Actions Locally
Use [act](https://github.com/nektos/act) to run GitHub Actions workflows locally before pushing:
```bash
# Install act
brew install act # macOS
sudo pacman -S act # Arch Linux
sudo apt install act # Debian/Ubuntu (via nix or manual install)
# List available jobs
act -l
# Run lint and typecheck jobs (fast)
act -j lint
act -j typecheck
# Run tests for Linux only (act simulates Linux)
act -j test --matrix os:ubuntu-latest
# Run specific Python version
act -j test --matrix os:ubuntu-latest --matrix python-version:3.12
# Run all jobs sequentially (stop on first failure)
act -j lint && act -j typecheck && act -j test --matrix os:ubuntu-latest
# Dry run (show what would execute)
act -n
```
**Note:** act uses Docker containers that simulate Linux runners. macOS/Windows matrix jobs will run in Linux
containers, so use `--matrix os:ubuntu-latest` for accurate local testing.
# Copyright
Nebius B.V. 2026, Licensed under the Apache License, Version 2.0 (see "LICENSE" file).
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"aiosqlite>=0.19.0",
"argclass>=1.0.0",
"httpx>=0.28.0",
"mcp>=1.0.0",
"pydantic>=2.0.0",
"furo>=2024.0.0; extra == \"dev\"",
"mypy>=1.8.0; extra == \"dev\"",
"myst-parser>=3.0.0; extra == \"dev\"",
"pytest-asyncio>=0.23.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\"",
"ruff>=0.2.0; extra == \"dev\"",
"sphinx-copybutton>=0.5.0; extra == \"dev\"",
"sphinx-design>=0.5.0; extra == \"dev\"",
"sphinx>=7.0.0; extra == \"dev\"",
"sphinxcontrib-mermaid>=0.9.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:11:46.582616 | contree_mcp-0.1.3.tar.gz | 345,657 | 88/71/244b6c126672cc47cae8841b5abcf71870cf1bb5df59c46d0ae9f8796177/contree_mcp-0.1.3.tar.gz | source | sdist | null | false | b6ebabd3a5928aa1647f9dc37465aa96 | 992e6678dcbdbdcbc4b3893e48cbc7438cdff71feed1b3fce6de3d6b64bbcdcc | 8871244b6c126672cc47cae8841b5abcf71870cf1bb5df59c46d0ae9f8796177 | Apache-2.0 | [
"LICENSE"
] | 224 |
2.3 | sandwich | 0.5.1 | DataVault 2.0 code gen | ## Data Vault 2.0 scaffolding tool
This tool is designed to streamline the process of creating Data Vault 2.0 entities,
such as hubs, links, and satellites.
As well as building information layer objects such as dim and fact tables
from a multidimensional paradigm.
### How it works:
User: provides a staging view `stg.[entity_name]` (or a table if the staging layer persisted)
with all requirements for the `[entity_name]` defined in the schema (how to define see below).
Tool:
1. Validates metadata of the provided staging view or table.
2. Generates the necessary DDL statements to create the Data Vault 2.0 entities.
3. Generates ELT procedures to load data to the generated entities.
4. Generates support procedures such as `meta.Drop_all_related_to_[entity_name]` and `elt.Run_all_related_to_[entity_name]`
#### App design (layers):
DV2Modeler (service)
1. gets user input (stg) and analyzes it, producing `stg_info`
2. chooses strategy (`scd2dim`, `link2fact`)
Strategy (algorithm)
1. validates staging using `stg_info`
2. generates schema using dialects handler
Dialect handler (repository)
1. creates DB objects for postgres or MSSQL database
```text
+----------------------+
| hub.[entity_name] |
+----------------------+
^
o 1.define +-------------------+ | 3.create
/|\ -------> | stg.[entity_name] | # +----------------------+
/ \ +-------------------+ /|\ ---------> | sat.[entity_name] |
User ---------------------------------------> / \ 3.create +----------------------+
2.use Tool
| 3.create
v
+----------------------+
| dim.[entity_name] |
+----------------------+
```
### How to define a staging view or table:
* `bk_` (BusinessKey) - at least one `bk_` column
* `hk_[entity_name]` (HashKey) - exactly one `hk_[entity_name]` column if you want a `hub` table created
* `LoadDate` - required by dv2 standard for an auditability
* `RecordSource` - required by dv2 standard for an auditability
* `HashDiff` - optional, required if you want to have a scd2 type `dim` table created
* `IsAvailable` - optional, required if you want to track missing/deleted records
* all other columns will be considered as business columns and will be included to the `sat` table definition
| staging fields | scd2dim profile | link2fact profile |
|--------------------|-----------------|-------------------|
| bk_ | ✅ | |
| hk_`[entity_name]` | ✅ | |
| LoadDate | ✅ | |
| RecordSource | ✅ | |
| HashDiff | ✅ | |
| IsAvailable | ✅ | |
```sql
-- staging view example for the scd2dim profile (mssql)
create view [stg].[UR_officers] as
select cast(31 as bigint) [bk_id]
, core.StringToHash1(cast(31 as bigint)) [hk_UR_officers]
, sysdatetime() [LoadDate]
, cast('LobSystem.dbo.officers_daily' as varchar(200)) [RecordSource]
, core.StringToHash8(
cast('uri' as nvarchar(100))
, cast('00000000000000' as varchar(20))
, cast('NATURAL_PERSON' as varchar(50))
, cast(null as varchar(20))
, cast('INDIVIDUALLY' as varchar(50))
, cast(0 as int)
, cast('2008-04-07' as date)
, cast('2008-04-07 18:00:54.000' as datetime)
) [HashDiff]
, cast('uri' as nvarchar(100)) [uri]
, cast('00000000000000' as varchar(20)) [at_legal_entity_registration_number]
, cast('NATURAL_PERSON' as varchar(50)) [entity_type]
, cast(null as varchar(20)) [legal_entity_registration_number]
, cast('INDIVIDUALLY' as varchar(50)) [rights_of_representation_type]
, cast(0 as int) [representation_with_at_least]
, cast('2008-04-07' as date) [registered_on]
, cast('2008-04-07 18:00:54.000' as datetime) [last_modified_at]
, cast(1 as bit) [IsAvailable]
```
### scd2dim profile columns mapping:
| stg | hub | sat | dim |
|--------------------|------------------------|----------------------------|--------------------|
| | | | hk_`[entity_name]` |
| BKs... | (uk)BKs... | BKs... | (pk)BKs... |
| hk_`[entity_name]` | (pk)hk_`[entity_name]` | (pk)(fk)hk_`[entity_name]` | |
| LoadDate | LoadDate | (pk)LoadDate | |
| RecordSource | RecordSource | RecordSource | |
| HashDiff | | HashDiff | |
| FLDs... | | FLDs... | FLDs... |
| IsAvailable | | IsAvailable | IsAvailable |
| | | | IsCurrent |
| | | | (pk)DateFrom |
| | | | DateTo |
### link2fact profile columns mapping:
| stg | link | sat | fact |
|--------------------|--------------------------------|----------------------------|------|
| HKs... | (uk)(fk)hk_`other_entity_name` | | |
| hk_`[entity_name]` | (pk)hk_`[entity_name]` | (pk)(fk)hk_`[entity_name]` | |
| <degenerate_field> | (uk)<degenerate_field> | <degenerate_field> | |
| LoadDate | LoadDate | LoadDate | |
| RecordSource | RecordSource | RecordSource | |
| FLDs... | | FLDs... | |
### Schemas:
* `core` - framework-related code
* `stg` - staging layer for both virtual (views) and materialized (tables)
* `hub` - hub tables
* `sat` - satellite tables
* `dim` - dimension tables (information vault)
* `fact` - fact tables (information vault)
* `elt` - ELT procedures
* `job` - top level ELT procedures
* `meta` - metadata vault
* `proxy` - source data for a materialized staging area (meant for wrapping external data sources as SQL views)
### DV2-related schemas layering
data -> ELT -> report
| LoB* data | staging (E) | raw vault (L) | business vault (T) | information vault |
|-----------|-------------|---------------|--------------------|-------------------|
| | stg | hub | sal | dim |
| | proxy | sat | | fact |
| | pool | link | | |
_* Line of Business applications_
### Usage diagram
```text
+ +-----------+ automation
+---- + -------> | Dv2Utils | -------+------+
| + uses +-----------+ |
| + | uses | creates
| + v |
| + uses +-----------+ uses |
+---- + -------> | Dv2Helper | --------------+
| + +-----------+ |
o + | |
/|\ + | DDL | python
/ \ ==========================================================
DWH Dev + creates | | database
| + v V
| + uses +--------+ uses +---------------+
+---- + -------> | entity | -----> | core objects |
+ +--------+ +---------------+
+
```
| text/markdown | Andrey Morozov | Andrey Morozov <andrey@morozov.lv> | null | null | null | DWH, Data Vault 2.0 | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Topic :: Database",
"Operating System :: OS Independent",
"Environment :: Console",
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Developers",
"Typing :: Typed"
] | [] | null | null | >=3.14 | [] | [] | [] | [
"sqlalchemy"
] | [] | [] | [] | [] | uv/0.9.11 {"installer":{"name":"uv","version":"0.9.11"},"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-20T14:11:40.832730 | sandwich-0.5.1.tar.gz | 19,255 | 2a/f1/52056ee4465a102bfa026b575d7ca067b95a039f5ac6facd39093f1bd362/sandwich-0.5.1.tar.gz | source | sdist | null | false | 36e4b6e05829411b3f2e147edc90b4b0 | e298fbeb6e559aa5ea609861069799a6fb475ffef48c22aa55ff6030027cd720 | 2af152056ee4465a102bfa026b575d7ca067b95a039f5ac6facd39093f1bd362 | null | [] | 218 |
2.4 | funtracks | 1.8.0a2 | Cell tracking data model | <p align="center">
<img src="docs/assets/logo.svg" alt="Funtracks Logo" width="128" height="128">
</p>
# Funtracks
A data model for cell tracking with actions, undo history, persistence, and more!
[](https://github.com/funkelab/funtracks/actions)
[](https://codecov.io/gh/funkelab/funtracks)
The full documentation can be found [here](https://funkelab.github.io/funtracks/).
----------------------------------
## Installation
`pip install funtracks`
Alternatively, you can use `uv` to install and run `funtracks` code.
## Issues
If you encounter any problems, please
[file an issue](https://github.com/funkelab/funtracks/issues)
along with a detailed description.
| text/markdown | null | Caroline Malin-Mayor <malinmayorc@janelia.hhmi.org> | null | null | BSD 3-Clause License | null | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"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.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Scientific/Engineering :: Image Processing"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"numpy<3,>=2",
"pydantic<3,>=2",
"networkx<4,>=3.4",
"psygnal>=0.14",
"scikit-image>=0.25",
"geff<2,>=1.1.3",
"dask>=2025.5.0",
"pandas>=2.3.3",
"zarr<4,>=2.18",
"numcodecs<0.16,>=0.13",
"tqdm>=4.66.1"
] | [] | [] | [] | [
"Bug Tracker, https://github.com/funkelab/funtracks/issues",
"Documentation, https://funkelab.github.io/funtracks/"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:11:38.198773 | funtracks-1.8.0a2.tar.gz | 127,454 | 72/d3/be78c10f2977849a0441abe3787cc364bbe94f9d2d92bac89d77371d266a/funtracks-1.8.0a2.tar.gz | source | sdist | null | false | 48a8238fc354d3df13d7385dfde9bd60 | ad423b4122747613998918ba957656c2e706fce3aed95e7d763f22b562cc5cb6 | 72d3be78c10f2977849a0441abe3787cc364bbe94f9d2d92bac89d77371d266a | null | [
"LICENSE"
] | 340 |
2.4 | sentry-cli | 3.2.1 | A command line utility to work with Sentry. | <p align="center">
<a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
<picture>
<source srcset="https://sentry-brand.storage.googleapis.com/sentry-logo-white.png" media="(prefers-color-scheme: dark)" />
<source srcset="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" media="(prefers-color-scheme: light), (prefers-color-scheme: no-preference)" />
<img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" alt="Sentry" width="280">
</picture>
</a>
</p>
# Sentry CLI
This is the repository for Sentry CLI, the official command line interface for Sentry.
Sentry CLI can be used for many tasks, including uploading debug symbols and source maps to Sentry, managing releases, and viewing Sentry data such as issues and logs.
## Installation and Usage
Please refer to [Sentry CLI's documentation page](https://docs.sentry.io/cli/).
## Compatibility
Sentry CLI officially supports [Sentry SaaS](https://sentry.io/) and [Sentry Self-Hosted](https://github.com/getsentry/self-hosted) versions 24.11.1 and above.
<details>
<summary><h3>Self-Hosted Sentry</h3></summary>
For self-hosted installations, only those features which were available in Sentry CLI at the time of the release of the given self-hosted version are supported, as new features may require server-side support. Additionally, some features, like the `sentry-cli build` commands, are restricted to Sentry SaaS.
Users who are using Sentry Self-Hosted versions older than 24.11.1 are encouraged to upgrade their Sentry Self-Hosted installations before using Sentry CLI versions 3.0.0 and above. For users who cannot upgrade, please use the version indicated in the table below.
| **Sentry Self-Hosted Version** | **Newest Compatible Sentry CLI Version** |
| ------------------------------ | --------------------------------------------------------------------- |
| ≥ 24.11.1 | [latest](https://github.com/getsentry/sentry-cli/releases/latest) |
| < 24.11.1 | [2.58.4](https://github.com/getsentry/sentry-cli/releases/tag/2.58.4) |
Note that we can only provide support for officially-supported Sentry Self-Hosted versions. We will not backport fixes for older Sentry CLI versions, even if they should be compatible with your self-hosted version.
</details>
## Versioning
Sentry CLI follows semantic versioning, according to [this versioning policy](VERSIONING.md).
## Compiling
In case you want to compile this yourself, you need to install at minimum the
following dependencies:
* Rust stable and Cargo
* Make, CMake and a C compiler
Use cargo to compile:
$ cargo build
Also, there is a Dockerfile that builds an Alpine-based Docker image with
`sentry-cli` in the PATH. To build and use it, run:
```sh
docker build -t sentry-cli .
docker run --rm -v $(pwd):/work sentry-cli --help
```
## Internal docs
Snapshot: [Sentry CLI distribution as of 2026-01-29](docs/snapshots/2026-01-29-sentry-cli-distribution.md).
| text/markdown | Sentry | oss@sentry.io | null | null | FSL-1.1-MIT | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy"
] | [] | https://github.com/getsentry/sentry-cli | null | >=3.7 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.1.0 CPython/3.11.2 | 2026-02-20T14:11:38.015189 | sentry_cli-3.2.1.tar.gz | 331,748 | 20/f8/536e34457be86b2edd920c69529341f0512f97562a59b8fff2dab5d0932b/sentry_cli-3.2.1.tar.gz | source | sdist | null | false | 0b539cc20a691caf17cab3ffe792a32a | f254c5a231023d52287077382ba13294de9de05dc2dd435aefd21470949590e5 | 20f8536e34457be86b2edd920c69529341f0512f97562a59b8fff2dab5d0932b | null | [
"LICENSE"
] | 3,717 |
2.4 | hugr | 0.15.4 | Quantinuum's common representation for quantum programs | hugr
===============
[![build_status][]](https://github.com/quantinuum/hugr/actions)
[![codecov][]](https://codecov.io/gh/quantinuum/hugr)
The Hierarchical Unified Graph Representation (HUGR, pronounced _hugger_) is the
common representation of quantum circuits and operations in the Quantinuum
ecosystem.
This library provides a pure-python implementation of the HUGR data model, and
a low-level API for constructing HUGR objects.
The API documentation for this package is [here](https://quantinuum.github.io/hugr/).
This library is intended to be used as a dependency for other high-level tools.
See [`guppylang`][] and [`tket2`][] for examples of such tools.
The HUGR specification is [here](https://github.com/quantinuum/hugr/blob/main/specification/hugr.md).
[`guppylang`]: https://pypi.org/project/guppylang/
[`tket2`]: https://github.com/quantinuum/tket2
## Installation
The package name is `hugr`. It can be installed from PyPI:
```bash
pip install hugr
```
The current releases are in alpha stage, and the API is subject to change.
## Usage
TODO
## Recent Changes
TODO
## Development
TODO
## License
This project is licensed under Apache License, Version 2.0 ([LICENSE][] or http://www.apache.org/licenses/LICENSE-2.0).
[build_status]: https://github.com/quantinuum/hugr/actions/workflows/ci-py.yml/badge.svg?branch=main
[codecov]: https://img.shields.io/codecov/c/gh/quantinuum/hugr?logo=codecov
[LICENSE]: https://github.com/quantinuum/hugr/blob/main/LICENCE
[CHANGELOG]: https://github.com/quantinuum/hugr/blob/main/hugr-py/CHANGELOG.md
| text/markdown; charset=UTF-8; variant=GFM | null | TKET development team <tket-support@quantinuum.com> | null | TKET development team <tket-support@quantinuum.com> | null | null | [
"Environment :: Console",
"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 :: Apache Software License",
"Operating System :: MacOS :: MacOS X",
"Operating System :: POSIX :: Linux",
"Operating System :: Microsoft :: Windows",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"graphviz>=0.20.3",
"pydantic~=2.8",
"pydantic-extra-types~=2.9",
"semver~=3.0",
"typing-extensions~=4.12",
"sphinx<10.0.0,>=8.1.3; extra == \"docs\"",
"furo; extra == \"docs\"",
"pytket>=1.34.0; extra == \"pytket\""
] | [] | [] | [] | [
"homepage, https://github.com/quantinuum/hugr/tree/main/hugr-py",
"repository, https://github.com/quantinuum/hugr/tree/main/hugr-py"
] | maturin/1.12.3 | 2026-02-20T14:11:24.043794 | hugr-0.15.4.tar.gz | 1,050,567 | f2/fe/676058e746b7509d2c80123c22444d81e5f470b7bdcd2c1159185b9a4749/hugr-0.15.4.tar.gz | source | sdist | null | false | ee7a7444c9e584e9c520a0684d673ebe | 0a0d72daa37854dd933fcea7c4ee0c715c21efdf2365700762f9c6f57afc0c50 | f2fe676058e746b7509d2c80123c22444d81e5f470b7bdcd2c1159185b9a4749 | null | [] | 2,234 |
2.1 | odoo-addon-l10n-it-delivery-note | 18.0.1.0.5 | Crea, gestisce e fattura i DDT partendo dalle consegne | .. image:: https://odoo-community.org/readme-banner-image
:target: https://odoo-community.org/get-involved?utm_source=readme
:alt: Odoo Community Association
============================
ITA - Documento di trasporto
============================
..
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! This file is generated by oca-gen-addon-readme !!
!! changes will be overwritten. !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! source digest: sha256:7e407a63e5642e24e05e9d2b3c84749acf0f77abf7825e750f7b1d84cccddd54
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png
:target: https://odoo-community.org/page/development-status
:alt: Beta
.. |badge2| image:: https://img.shields.io/badge/license-AGPL--3-blue.png
:target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
:alt: License: AGPL-3
.. |badge3| image:: https://img.shields.io/badge/github-OCA%2Fl10n--italy-lightgray.png?logo=github
:target: https://github.com/OCA/l10n-italy/tree/18.0/l10n_it_delivery_note
:alt: OCA/l10n-italy
.. |badge4| image:: https://img.shields.io/badge/weblate-Translate%20me-F47D42.png
:target: https://translation.odoo-community.org/projects/l10n-italy-18-0/l10n-italy-18-0-l10n_it_delivery_note
:alt: Translate me on Weblate
.. |badge5| image:: https://img.shields.io/badge/runboat-Try%20me-875A7B.png
:target: https://runboat.odoo-community.org/builds?repo=OCA/l10n-italy&target_branch=18.0
:alt: Try me on Runboat
|badge1| |badge2| |badge3| |badge4| |badge5|
**English**
This module manage the Italian DDT (Delivery note).
From a picking is possible to generate a Delivery Note and group more
picking in one delivery note. It's also possible to invoice from the
delivery note form.
This module is alternative to ``l10n_it_ddt``, it follows the Odoo way
to process sale orders, pickings and invoices.
You can't have both ``l10n_it_ddt`` and ``l10n_it_delivery_note``
installed together.
There are two available settings:
- Base (default): one picking, one DN.
- Advanced: more picking in one DN.
**Italiano**
Questo modulo consente di gestire i DDT.
Da un prelievo è possibile generare un DDT e raggruppare più prelievi in
un DDT. È anche possibile fatturare dalla scheda del DDT.
Questo modulo è un alternativa al modulo ``l10n_it_ddt``, segue la
modalità Odoo di gestire ordini di vendita, prelievi e fatture.
Non è possibile avere installati contemporaneamente ``l10n_it_ddt`` e
``l10n_it_delivery_note``.
Ci sono due impostazioni possibili.
- Base (predefinita): un prelievo, un DDT.
- Avanzata: più prelievi in un DDT.
**Table of contents**
.. contents::
:local:
Configuration
=============
To configure this module, go to:
1. *Inventory → Configuration → Settings - Delivery Notes*
Checking 'Use Advanced DN Features' allows you to manage more picking
on one delivery note.
Checking 'Display Ref. Order in Delivery Note Report' or 'Display
Ref. Customer in Delivery Note Report" enables in report fields
relating DN line to SO (if applicable).
Checking 'Display Carrier in Delivery Note Report' enables in report
field 'Carrier'.
Checking 'Display Delivery Method in Delivery Note Report' enables in
report field 'Delivery Method'.
2. *Inventory → Configuration → Warehouse Management → Delivery Note
Types*
In delivery note type you can specify if the product price have to be
printed in the delivery note report/slip.
- *Inventory → Configuration → Delivery Notes → Conditions of
Transport*
- *Inventory → Configuration → Delivery Notes → Appearances of Goods*
- *Inventory → Configuration → Delivery Notes → Reasons of Transport*
- *Inventory → Configuration → Delivery Notes → Methods of Transport*
3. *Settings → User & Companies → Users*
In the user profile settings, "Show product information in DN lines"
allows showing prices in the form.
Usage
=====
Funzionalità base
-----------------
Quando un prelievo viene validato compare una scheda DDT.
Nella scheda fare clic su "Crea nuovo", si apre un procedura guidata
dove scegliere il tipo di DDT, quindi confermare. Immettere i dati
richiesti e poi fare clic su "Valida" per numerare il DDT.
Una volta validato, è possibile emettere fattura direttamente dal DDT se
il DDT stesso è di tipo consegna a cliente (In uscita) e si hanno i
permessi sull'utente.
È possibile annullare il DDT, reimpostarlo a bozza e poi modificarlo. Se
il DDT è fatturato il numero e la data non sono modificabili.
Per i trasferimenti tra magazzini creare un prelievo di tipo interno con
le relative ubicazioni. Validare il prelievo visualizza la scheda DDT.
È possibile anche avere DDT in ingresso, ovvero dopo la validazione del
prelievo selezionare la scheda per indicare il numero del DDT fornitore
e la data.
Funzionalità avanzata
---------------------
Vengono attivate varie funzionalità aggiuntive:
- più prelievi per un DDT
- selezione multipla di prelievi e generazione dei DDT
- aggiunta righe nota e righe sezione descrittive.
- lista dei DDT.
Il report DDT stampa in righe aggiuntive i lotti/seriali e le scadenze
del prodotto.
Il prezzo può essere indicato anche nel report DDT se nel tipo DDT è
indicata la stampa prezzi. La visibilità dei prezzi si trova nei
permessi dell'utente.
Le fatture generate dai DDT contengono i riferimenti al DDT stesso nelle
righe nota.
Accesso da portale
------------------
Gli utenti portal hanno la possibilità di scaricare i report dei DDT di
cui loro o la loro azienda padre sono impostati come destinatari o
indirizzo di spedizione.
Bug Tracker
===========
Bugs are tracked on `GitHub Issues <https://github.com/OCA/l10n-italy/issues>`_.
In case of trouble, please check there if your issue has already been reported.
If you spotted it first, help us to smash it by providing a detailed and welcomed
`feedback <https://github.com/OCA/l10n-italy/issues/new?body=module:%20l10n_it_delivery_note%0Aversion:%2018.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
Do not contact contributors directly about support or help with technical issues.
Credits
=======
Authors
-------
* Marco Calcagni
* Gianmarco Conte
* Link IT Europe Srl
Contributors
------------
- Riccardo Bellanova <r.bellanova@apuliasoftware.it>
- Matteo Bilotta <mbilotta@linkeurope.it>
- Giuseppe Borruso <gborruso@dinamicheaziendali.it>
- Marco Calcagni <mcalcagni@dinamicheaziendali.it>
- Marco Colombo <marco.colombo@gmail.com>
- Gianmarco Conte <gconte@dinamicheaziendali.it>
- Letizia Freda <letizia.freda@netfarm.it>
- Andrea Piovesana <andrea.m.piovesana@gmail.com>
- Alex Comba <alex.comba@agilebg.com>
- `Ooops <https://www.ooops404.com>`__:
- Giovanni Serra <giovanni@gslab.it>
- Foresti Francesco <francesco.foresti@ooops404.com>
- Nextev Srl <odoo@nextev.it>
- `PyTech-SRL <https://www.pytech.it>`__:
- Alessandro Uffreduzzi <alessandro.uffreduzzi@pytech.it>
- Sebastiano Picchi <sebastiano.picchi@pytech.it>
- `Aion Tech <https://aiontech.company/>`__:
- Simone Rubino <simone.rubino@aion-tech.it>
Maintainers
-----------
This module is maintained by the OCA.
.. image:: https://odoo-community.org/logo.png
:alt: Odoo Community Association
:target: https://odoo-community.org
OCA, or the Odoo Community Association, is a nonprofit organization whose
mission is to support the collaborative development of Odoo features and
promote its widespread use.
.. |maintainer-MarcoCalcagni| image:: https://github.com/MarcoCalcagni.png?size=40px
:target: https://github.com/MarcoCalcagni
:alt: MarcoCalcagni
.. |maintainer-aleuffre| image:: https://github.com/aleuffre.png?size=40px
:target: https://github.com/aleuffre
:alt: aleuffre
.. |maintainer-renda-dev| image:: https://github.com/renda-dev.png?size=40px
:target: https://github.com/renda-dev
:alt: renda-dev
Current `maintainers <https://odoo-community.org/page/maintainer-role>`__:
|maintainer-MarcoCalcagni| |maintainer-aleuffre| |maintainer-renda-dev|
This module is part of the `OCA/l10n-italy <https://github.com/OCA/l10n-italy/tree/18.0/l10n_it_delivery_note>`_ project on GitHub.
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
| text/x-rst | Marco Calcagni, Gianmarco Conte, Link IT Europe Srl, Odoo Community Association (OCA) | support@odoo-community.org | null | null | AGPL-3 | null | [
"Programming Language :: Python",
"Framework :: Odoo",
"Framework :: Odoo :: 18.0",
"License :: OSI Approved :: GNU Affero General Public License v3"
] | [] | https://github.com/OCA/l10n-italy | null | >=3.10 | [] | [] | [] | [
"odoo-addon-delivery_carrier_partner==18.0.*",
"odoo==18.0.*"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:11:18.075438 | odoo_addon_l10n_it_delivery_note-18.0.1.0.5-py3-none-any.whl | 145,927 | 7d/2d/5b92c77b1a0b764468ddfc33d5381b05e5018a134674a4053af93f817878/odoo_addon_l10n_it_delivery_note-18.0.1.0.5-py3-none-any.whl | py3 | bdist_wheel | null | false | 1365ed5aa6cbfef75c277c02ed6058fd | 3cd8fa486cc13c789cd657ea6191945b7553a75986a84a1fa2fb68dea80bf3db | 7d2d5b92c77b1a0b764468ddfc33d5381b05e5018a134674a4053af93f817878 | null | [] | 90 |
2.4 | fibr | 0.3.0 | Add your description here | # fibr [faɪbə] - File Browser
A simple file browser similar to [Midnight Commander](https://midnight-commander.org) featuring:
- traditional dual-pane layout
- find-as-you-type per default
- ~~basic file operations vai UI: copy, move, mkdir~~ _Not implemented yet!_
- view/edit file delegated to external tools
And that's about it!
It's a very short and select feature set, so this might not be the tool for you. If you're looking for a comprehensive TUI file manager and are not into the classic Norton Commander look & feel, some popular choices to check out are [lf](https://github.com/gokcehan/lf), [superfile](https://github.com/yorukot/superfile) or [yazi](https://github.com/sxyazi/yazi).
fibr was created to "scratch an itch" and is not looking to become a contender in the space of TUI file managers.
The project status is currently "alpha", i.e. it is neither feature-complete nor extensively tested.
Written in Python using the excellent [Textual](https://textual.textualize.io) framework.
## Installation
fibr is on [PyPi](https://pypi.org/project/fibr/), you can use the package manager of your choice to set yourself up. Here is an example using `uv`:
```bash
uv tool install fibr
```
## Usage
If you're familiar with Midnight Commander, the basics are identical:
- cursor up/down (⬆, ⬇) to move a line
- page up/down (⇞, ⇟) to move a page
- home/end (⇱, ⇲) to jump top/bottom
- enter (⏎) to enter a directory
- tab (⇥) to switch panels
- F3 to open the highlighted file in an external viewer (`$PAGER`)
- F4 to open the highlighted file in an external editor (`$EDITOR`)
- ~~F5 to copy file/directory~~ _Not implemented yet!_
- ~~F6 to move file/directory~~ _Not implemented yet!_
- ~~F7 to create directory~~ _Not implemented yet!_
- ~~F8 to delete file/directory~~ _Not implemented yet!_
- any alphanumeric key triggers "find-as-you-type"
- escape (⎋) to cancel
- tab/shift tab (⇥, ⇧⇥) to jump to next/previous match
- enter (⏎) to confirm (will enter directory if search matches)
- ctrl+o (⌃o) to open a subshell
- ctrl+r (^r) to reload directory from disk
- ctrl+t (⌃t) to toggle file selection
> [!NOTE]
> By default, the content of a directory is cached on first read and not automatically refreshed, even when you switch directories. You have to manually issue a reload to see newly created/deleted/updated files.
> This behavior is under review.
## License
[GPL-2.0-or-later](https://github.com/dehesselle/fibr/blob/main/LICENSE)
| text/markdown | null | René de Hesselle <dehesselle@web.de> | null | null | GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
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
this service 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.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
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
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the 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 a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE 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.
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
convey 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 General Public License as published by
the Free Software Foundation; either version 2 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 General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. | null | [
"Development Status :: 3 - Alpha",
"Environment :: Console",
"License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)",
"Programming Language :: Python :: 3.12",
"Topic :: Terminals",
"Topic :: Utilities"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"peewee>=3.18.2",
"platformdirs>=4.5.0",
"textual~=6.4"
] | [] | [] | [] | [
"Source, https://github.com/dehesselle/fibr"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:11:07.001109 | fibr-0.3.0.tar.gz | 30,026 | 1b/6a/adc4fdbb4c9445ba922246f28fb05647415fb9315cb2826586746e05458e/fibr-0.3.0.tar.gz | source | sdist | null | false | ff9c36ccea8e23f304115356c4781652 | 5031315900eb6a98c98b4d3d305dfb1c3e36cfa4a1a65515928b18732cce2a9f | 1b6aadc4fdbb4c9445ba922246f28fb05647415fb9315cb2826586746e05458e | null | [
"LICENSE"
] | 208 |
2.4 | incognia-python | 3.5.0 | Python lightweight client library for Incognia APIs | # Incognia API Python Client 🐍
[](https://www.python.org/downloads/release/python-360/)
## Installation
You can install the IncogniaAPI using the following command:
```shell
pip install incognia-python
```
## Usage
### Configuration
Before calling the API methods, you need to create an instance of the `IncogniaAPI` class.
```python3
from incognia.api import IncogniaAPI
api = IncogniaAPI('client-id', 'client-secret')
```
### Incognia API
The implementation is based on the [Incognia API Reference](https://developer.incognia.com/docs/).
#### Authentication
Authentication is done transparently, so you don't need to worry about it.
#### Registering New Signup
This method registers a new signup for the given request token and a structured address, an address
line or coordinates, returning a `dict`, containing the risk assessment and supporting evidence:
```python3
from incognia.api import IncogniaAPI
from incognia.models import StructuredAddress, Coordinates
api = IncogniaAPI('client-id', 'client-secret')
# with structured address, a dict:
structured_address: StructuredAddress = {
'locale': 'en-US',
'country_name': 'United States of America',
'country_code': 'US',
'state': 'NY',
'city': 'New York City',
'borough': 'Manhattan',
'neighborhood': 'Midtown',
'street': 'W 34th St.',
'number': '20',
'complements': 'Floor 2',
'postal_code': '10001'
}
assessment: dict = api.register_new_signup('request-token', structured_address=structured_address)
# with address line:
address_line: str = '350 Fifth Avenue, Manhattan, New York 10118'
assessment: dict = api.register_new_signup('request-token', address_line=address_line)
# with coordinates, a dict:
coordinates: Coordinates = {
'lat': 40.74836007062138,
'lng': -73.98509720487937
}
assessment: dict = api.register_new_signup('request-token', address_coordinates=coordinates)
# with external_id:
external_id: str = 'external-id'
assessment: dict = api.register_new_signup('request-token', external_id=external_id)
# with policy_id:
policy_id: str = 'policy-id'
assessment: dict = api.register_new_signup('request-token', policy_id=policy_id)
# with account_id:
account_id: str = 'account-id'
assessment: dict = api.register_new_signup('request-token', account_id=account_id)
```
#### Registering Feedback
This method registers a feedback event for the given identifiers (optional arguments) related to a
signup, login or payment.
```python3
import datetime as dt
from incognia.api import IncogniaAPI
from incognia.feedback_events import FeedbackEvents # feedbacks are strings.
api = IncogniaAPI('client-id', 'client-secret')
api.register_feedback(FeedbackEvents.ACCOUNT_TAKEOVER,
occurred_at=dt.datetime(2024, 7, 22, 15, 20, 0, tzinfo=dt.timezone.utc),
request_token='request-token',
account_id='account-id')
```
#### Registering Payment
This method registers a new payment for the given request token and account, returning a `dict`,
containing the risk assessment and supporting evidence.
```python3
from typing import List
from incognia.api import IncogniaAPI
from incognia.models import TransactionAddress, PaymentValue, PaymentMethod
api = IncogniaAPI('client-id', 'client-secret')
addresses: List[TransactionAddress] = [
{
'type': 'shipping',
'structured_address': {
'locale': 'pt-BR',
'country_name': 'Brasil',
'country_code': 'BR',
'state': 'SP',
'city': 'São Paulo',
'borough': '',
'neighborhood': 'Bela Vista',
'street': 'Av. Paulista',
'number': '1578',
'complements': 'Andar 2',
'postal_code': '01310-200'
},
'address_coordinates': {
'lat': -23.561414,
'lng': -46.6558819
}
}
]
payment_value: PaymentValue = {
'amount': 5.0,
'currency': 'BRL'
}
payment_methods: List[PaymentMethod] = [
{
'type': 'credit_card',
'credit_card_info': {
'bin': '123456',
'last_four_digits': '1234',
'expiry_year': '2027',
'expiry_month': '10'
}
},
{
'type': 'debit_card',
'debit_card_info': {
'bin': '123456',
'last_four_digits': '1234',
'expiry_year': '2027',
'expiry_month': '10'
}
}
]
policy_id: str = 'policy-id'
assessment: dict = api.register_payment('request-token',
'account-id',
'external-id',
addresses=addresses,
payment_value=payment_value,
payment_methods=payment_methods,
policy_id=policy_id)
```
#### Registering Login
This method registers a new login for the given request token and account, returning a `dict`,
containing the risk assessment and supporting evidence.
```python3
from incognia.api import IncogniaAPI
api = IncogniaAPI('client-id', 'client-secret')
policy_id: str = 'policy-id'
assessment: dict = api.register_login('request-token',
'account-id',
'external-id',
policy_id='policy_id')
```
## Error Handling
Every method call can throw `IncogniaHTTPError` and `IncogniaError`.
`IncogniaHTTPError` is thrown when the API returned an unexpected http status code.
`IncogniaError` represents unknown errors, like required parameters none or empty.
## How to Contribute
Your contributions are highly appreciated. If you have found a bug or if you have a feature request,
please report them at this repository
[issues section](https://github.com/inloco/incognia-python/issues).
### Development
#### Versioning
This project uses [Semantic Versioning](https://semver.org/), where version follows
`v{MAJOR}.{MINOR}.{PATCH}` format. In summary:
- _Major version update_ - Major functionality changes. Might not have direct backward
compatibility.
For example, multiple public API parameter changes.
- _Minor version update_ - Additional features. Major bug fixes. Might have some minor backward
compatibility issues. For example, an extra parameter on a callback function.
- _Patch version update_ - Minor features. Bug fixes. Full backward compatibility. For example,
extra fields added to the public structures with version bump.
#### Release
On GitHub, you should merge your changes to the `main` branch, create the git
[versioning](#Versioning) tag and finally push those changes:
```shell
$ git checkout main
$ git pull
$ git merge <your_branch>
$ git tag -a v<version> -m "<description>"
$ git push origin HEAD --tags
```
- example:
```shell
$ git checkout main
$ git pull
$ git merge feat/some-feature
$ git tag -a v2.1.0 -m "This release adds some feature..."
$ git push origin HEAD --tags
```
Our CI will build images with the tagged version and publish them
to [our PyPI repository](https://pypi.org/project/incognia-python/).
## What is Incognia?
Incognia is a location identity platform for mobile apps that enables:
- Real-time address verification for onboarding
- Frictionless authentication
- Real-time transaction verification
## License
[](https://opensource.org/licenses/MIT)
| text/markdown | Incognia | opensource@incognia.com | null | null | MIT | null | [
"Operating System :: OS Independent",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9"
] | [] | https://github.com/inloco/incognia-python | null | null | [] | [] | [] | [
"requests"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:10:51.288261 | incognia_python-3.5.0.tar.gz | 20,313 | 91/3f/2b31297353e14d63a555cf44d6dc9673a5c00755312eecfa939fec2c6d11/incognia_python-3.5.0.tar.gz | source | sdist | null | false | 00e14f81f0d2a10b566f4d3596b24cdd | a020fbf70b01c2bf172a5c3ffa362e3cb3a307cc9473cefa42231afa832b1eda | 913f2b31297353e14d63a555cf44d6dc9673a5c00755312eecfa939fec2c6d11 | null | [
"LICENSE.txt"
] | 247 |
2.4 | latticedb | 0.2.1 | Embedded knowledge graph database for AI and RAG applications | # LatticeDB Python Bindings
Python bindings for [LatticeDB](https://github.com/jeffhajewski/latticedb), an embedded knowledge graph database for AI/RAG applications.
## Installation
```bash
pip install latticedb
```
The native shared library (`liblattice.dylib` / `liblattice.so`) must be available on the system. Install it via the [install script](https://github.com/jeffhajewski/latticedb#installation) or build from source with `zig build shared`.
## Quick Start
```python
import numpy as np
from latticedb import Database
with Database("knowledge.db", create=True, enable_vector=True, vector_dimensions=4) as db:
# Create nodes, edges, and index content
with db.write() as txn:
alice = txn.create_node(
labels=["Person"],
properties={"name": "Alice", "age": 30},
)
bob = txn.create_node(
labels=["Person"],
properties={"name": "Bob", "age": 25},
)
txn.create_edge(alice.id, bob.id, "KNOWS")
# Index text for full-text search
txn.fts_index(alice.id, "Alice works on machine learning research")
txn.fts_index(bob.id, "Bob studies deep learning and neural networks")
# Store vector embeddings
txn.set_vector(alice.id, "embedding", np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32))
txn.set_vector(bob.id, "embedding", np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float32))
txn.commit()
# Query with Cypher
result = db.query("MATCH (n:Person) WHERE n.age > 20 RETURN n.name, n.age")
for row in result:
print(row)
# Vector similarity search
query_vec = np.array([0.9, 0.1, 0.0, 0.0], dtype=np.float32)
for r in db.vector_search(query_vec, k=2):
print(f"Node {r.node_id}: distance={r.distance:.4f}")
# Full-text search
for r in db.fts_search("machine learning"):
print(f"Node {r.node_id}: score={r.score:.4f}")
# Fuzzy search (typo-tolerant)
for r in db.fts_search_fuzzy("machin lerning"):
print(f"Node {r.node_id}: score={r.score:.4f}")
```
## API Reference
### Database
```python
Database(
path: str | Path,
*,
create: bool = False, # Create if doesn't exist
read_only: bool = False, # Open in read-only mode
cache_size_mb: int = 100, # Page cache size
enable_vector: bool = False, # Enable vector storage
vector_dimensions: int = 128 # Vector dimensions
)
```
#### Methods
- `open()` / `close()` - Open/close the database (also works as context manager)
- `read()` - Start a read-only transaction (context manager)
- `write()` - Start a read-write transaction (context manager)
- `query(cypher, parameters=None)` - Execute a Cypher query
- `vector_search(vector, k=10, ef_search=64)` - k-NN vector search
- `fts_search(query, limit=10)` - Full-text search
- `fts_search_fuzzy(query, limit=10, max_distance=0, min_term_length=0)` - Fuzzy full-text search
- `cache_clear()` - Clear the query cache
- `cache_stats()` - Get cache hit/miss statistics
### Transaction
#### Read Operations
- `get_node(node_id)` - Get a node by ID, returns `Node` or `None`
- `node_exists(node_id)` - Check if a node exists
- `get_property(node_id, key)` - Get a property value
- `get_outgoing_edges(node_id)` - Get outgoing edges from a node
- `get_incoming_edges(node_id)` - Get incoming edges to a node
- `is_read_only` / `is_active` - Transaction state
#### Write Operations
- `create_node(labels=[], properties=None)` - Create a node
- `delete_node(node_id)` - Delete a node
- `set_property(node_id, key, value)` - Set a property on a node
- `set_vector(node_id, key, vector)` - Set a vector embedding
- `batch_insert(label, vectors)` - Batch insert nodes with vectors (see below)
- `fts_index(node_id, text)` - Index text for full-text search
- `create_edge(source_id, target_id, edge_type)` - Create an edge
- `delete_edge(source_id, target_id, edge_type)` - Delete an edge
- `commit()` / `rollback()` - Commit or rollback the transaction
### Batch Insert
Insert many nodes with vectors in a single efficient call:
```python
import numpy as np
with Database("vectors.db", create=True, enable_vector=True, vector_dimensions=128) as db:
with db.write() as txn:
vectors = np.random.rand(1000, 128).astype(np.float32)
node_ids = txn.batch_insert("Document", vectors)
print(f"Created {len(node_ids)} nodes")
txn.commit()
```
### Full-Text Search
#### Exact Search
```python
results = db.fts_search("machine learning", limit=10)
for r in results:
print(f"Node {r.node_id}: score={r.score:.4f}")
```
#### Fuzzy Search (Typo-Tolerant)
```python
# Finds "machine learning" even with typos
results = db.fts_search_fuzzy("machne lerning", limit=10)
# Control fuzzy matching sensitivity
results = db.fts_search_fuzzy(
"machne",
limit=10,
max_distance=2, # Max edit distance (default: 2)
min_term_length=4, # Min term length for fuzzy matching (default: 4)
)
```
### Embeddings
LatticeDB includes a built-in hash embedding function and an HTTP client for external embedding services.
#### Hash Embeddings (Built-in)
Deterministic, no external service needed. Useful for testing or simple keyword-based similarity:
```python
from latticedb import hash_embed
vec = hash_embed("hello world", dimensions=128)
print(vec.shape) # (128,)
```
#### HTTP Embedding Client
Connect to Ollama, OpenAI, or compatible APIs:
```python
from latticedb import EmbeddingClient, EmbeddingApiFormat
# Ollama (default)
with EmbeddingClient("http://localhost:11434") as client:
vec = client.embed("hello world")
# OpenAI-compatible API
with EmbeddingClient(
"https://api.openai.com/v1",
model="text-embedding-3-small",
api_format=EmbeddingApiFormat.OPENAI,
api_key="sk-...",
) as client:
vec = client.embed("hello world")
```
### Edge Traversal
```python
with db.read() as txn:
outgoing = txn.get_outgoing_edges(node_id)
for edge in outgoing:
print(f"{edge.source_id} --[{edge.edge_type}]--> {edge.target_id}")
incoming = txn.get_incoming_edges(node_id)
for edge in incoming:
print(f"{edge.source_id} --[{edge.edge_type}]--> {edge.target_id}")
```
### Cypher Queries
```python
# Pattern matching
result = db.query("MATCH (n:Person) RETURN n.name")
# With parameters
result = db.query(
"MATCH (n:Person) WHERE n.name = $name RETURN n",
parameters={"name": "Alice"},
)
# Vector similarity in Cypher
result = db.query(
"MATCH (n:Document) WHERE n.embedding <=> $vec < 0.5 RETURN n.title",
parameters={"vec": query_vector},
)
# Full-text search in Cypher
result = db.query(
'MATCH (n:Document) WHERE n.content @@ "machine learning" RETURN n.title'
)
# Data mutation
db.query("CREATE (n:Person {name: 'Charlie', age: 35})")
db.query("MATCH (n:Person {name: 'Charlie'}) SET n.age = 36")
db.query("MATCH (n:Person {name: 'Charlie'}) DETACH DELETE n")
```
### Query Cache
```python
# Get cache statistics
stats = db.cache_stats()
print(f"Entries: {stats['entries']}, Hits: {stats['hits']}, Misses: {stats['misses']}")
# Clear the cache
db.cache_clear()
```
## Supported Property Types
- `None` - Null value
- `bool` - Boolean
- `int` - 64-bit integer
- `float` - 64-bit float
- `str` - UTF-8 string
- `bytes` - Binary data
## Error Handling
```python
from latticedb import LatticeError, LatticeNotFoundError, LatticeIOError
try:
with Database("nonexistent.db") as db:
pass
except LatticeNotFoundError:
print("Database not found")
except LatticeIOError:
print("I/O error")
except LatticeError as e:
print(f"Error: {e}")
```
## Requirements
- Python 3.9+
- NumPy (for vector operations)
- The native LatticeDB library (`liblattice.dylib` / `liblattice.so`)
## License
MIT
| text/markdown | null | Jeff Hajewski <jeff@latticedb.dev> | null | Jeff Hajewski <jeff@latticedb.dev> | MIT | database, graph, vector, embeddings, rag, ai, knowledge-graph | [
"Development Status :: 3 - Alpha",
"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 :: Database",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"numpy>=1.20.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"mypy>=1.0.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/jeffhajewski/latticedb",
"Documentation, https://latticedb.dev",
"Repository, https://github.com/jeffhajewski/latticedb",
"Issues, https://github.com/jeffhajewski/latticedb/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:10:32.420899 | latticedb-0.2.1.tar.gz | 25,268 | 5d/28/ac05ea06dd827dda214e63618f4a3aa46dd5f2490bcd9a708eaf3b7703f3/latticedb-0.2.1.tar.gz | source | sdist | null | false | 86a3f12c819cc71ddb6f60f93ff7ae31 | 193a6fb8f826f0435978b97a5603d3d596c9f42813f52778d1cbf95da502104a | 5d28ac05ea06dd827dda214e63618f4a3aa46dd5f2490bcd9a708eaf3b7703f3 | null | [] | 397 |
2.4 | tensordict-nightly | 2026.2.20 | TensorDict is a pytorch dedicated tensor container. | <!--- BADGES: START --->
<!---
[](https://pytorch.github.io/tensordict/)
--->
[][#docs-package]
[](https://discord.gg/tz3TgTAe3D)
[][#docs-package-benchmark]
[](https://www.python.org/downloads/)
[][#github-license]
<a href="https://pypi.org/project/tensordict"><img src="https://img.shields.io/pypi/v/tensordict" alt="pypi version"></a>
<a href="https://pypi.org/project/tensordict-nightly"><img src="https://img.shields.io/pypi/v/tensordict-nightly?label=nightly" alt="pypi nightly version"></a>
[][#pepy-package]
[)][#pepy-package-nightly]
[][#codecov-package]
[][#circleci-package]
[][#conda-forge-package]
[][#conda-forge-package]
[](https://github.com/pytorch/tensordict/actions/workflows/nightly_orchestrator.yml)
[](https://pytorch.github.io/tensordict/nightly-status/)
[](https://pytorch.github.io/tensordict/flaky/)
[#docs-package]: https://pytorch.github.io/tensordict/
[#docs-package-benchmark]: https://pytorch.github.io/tensordict/dev/bench/
[#github-license]: https://github.com/pytorch/tensordict/blob/main/LICENSE
[#pepy-package]: https://pepy.tech/project/tensordict
[#pepy-package-nightly]: https://pepy.tech/project/tensordict-nightly
[#codecov-package]: https://codecov.io/gh/pytorch/tensordict
[#circleci-package]: https://circleci.com/gh/pytorch/tensordict
[#conda-forge-package]: https://anaconda.org/conda-forge/tensordict
<!--- BADGES: END --->
# 📖 TensorDict
TensorDict is a dictionary-like class that inherits properties from tensors, making it easy to work with collections of
tensors in PyTorch. It provides a simple and intuitive way to manipulate and process tensors, allowing you to focus on
building and training your models.
[**Key Features**](#key-features) |
[**Examples**](#examples) |
[**Installation**](#installation) |
[**Citation**](#citation) |
[**License**](#license)
## Key Features
TensorDict makes your code-bases more _readable_, _compact_, _modular_ and _fast_.
It abstracts away tailored operations, making your code less error-prone as it takes care of
dispatching the operation on the leaves for you.
The key features are:
- 🧮 **Composability**: `TensorDict` generalizes `torch.Tensor` operations to collection of tensors.
- ⚡️ **Speed**: asynchronous transfer to device, fast node-to-node communication through `consolidate`, compatible with `torch.compile`.
- ✂️ **Shape operations**: Perform tensor-like operations on TensorDict instances, such as indexing, slicing or
concatenation.
- 🌐 **Distributed / multiprocessed capabilities**: Easily distribute TensorDict instances across multiple workers,
devices and machines.
- 💾 **Serialization** and memory-mapping
- λ **Functional programming** and compatibility with `torch.vmap`
- 📦 **Nesting**: Nest TensorDict instances to create hierarchical structures.
- ⏰ **Lazy preallocation**: Preallocate memory for TensorDict instances without initializing the tensors.
- 📝 **Specialized dataclass** for torch.Tensor ([`@tensorclass`](#tensorclass))
## Examples
This section presents a couple of stand-out applications of the library.
Check our [**Getting Started**](GETTING_STARTED.md) guide for an overview of TensorDict's features!
### Fast copy on device
`TensorDict` optimizes transfers from/to device to make them safe and fast.
By default, data transfers will be made asynchronously and synchronizations will be called whenever needed.
```python
# Fast and safe asynchronous copy to 'cuda'
td_cuda = TensorDict(**dict_of_tensor, device="cuda")
# Fast and safe asynchronous copy to 'cpu'
td_cpu = td_cuda.to("cpu")
# Force synchronous copy
td_cpu = td_cuda.to("cpu", non_blocking=False)
```
### Coding an optimizer
For instance, using `TensorDict` you can code the Adam optimizer as you would for a single `torch.Tensor` and apply
that to a `TensorDict` input as well. On `cuda`, these operations will rely on fused kernels, making it very fast to
execute:
```python
class Adam:
def __init__(self, weights: TensorDict, alpha: float=1e-3,
beta1: float=0.9, beta2: float=0.999,
eps: float = 1e-6):
# Lock for efficiency
weights = weights.lock_()
self.weights = weights
self.t = 0
self._mu = weights.data.clone()
self._sigma = weights.data.mul(0.0)
self.beta1 = beta1
self.beta2 = beta2
self.alpha = alpha
self.eps = eps
def step(self):
self._mu.mul_(self.beta1).add_(self.weights.grad, 1 - self.beta1)
self._sigma.mul_(self.beta2).add_(self.weights.grad.pow(2), 1 - self.beta2)
self.t += 1
mu = self._mu.div_(1-self.beta1**self.t)
sigma = self._sigma.div_(1 - self.beta2 ** self.t)
self.weights.data.add_(mu.div_(sigma.sqrt_().add_(self.eps)).mul_(-self.alpha))
```
### Training a model
Using tensordict primitives, most supervised training loops can be rewritten in a generic way:
```python
for i, data in enumerate(dataset):
# the model reads and writes tensordicts
data = model(data)
loss = loss_module(data)
loss.backward()
optimizer.step()
optimizer.zero_grad()
```
With this level of abstraction, one can recycle a training loop for highly heterogeneous task.
Each individual step of the training loop (data collection and transform, model prediction, loss computation etc.)
can be tailored to the use case at hand without impacting the others.
For instance, the above example can be easily used across classification and segmentation tasks, among many others.
## Installation
**With Pip**:
To install the latest stable version of tensordict, simply run
```bash
pip install tensordict
```
This will work with Python 3.7 and upward as well as PyTorch 1.12 and upward.
To enjoy the latest features, one can use
```bash
pip install tensordict-nightly
```
**With uv + PyTorch nightlies**:
If you're using a **PyTorch nightly** (e.g. installed from the PyTorch nightly wheel index), then for **editable**
installs you should install tensordict with **`--no-deps`**.
This avoids uv re-resolving `torch` from its configured indexes (by default: PyPI), which can otherwise replace an
existing nightly with the latest stable `torch`.
This is an **uv-specific** behavior; plain `pip install -e .` typically won’t replace an already-installed PyTorch
nightly.
To keep a nightly `torch` with an editable install:
- install without resolving deps (**recommended**):
```bash
uv pip install -e . --no-deps
```
- or (less recommended) explicitly point uv at the PyTorch nightly wheel index (CPU shown; use the appropriate backend directory like `cu126/`):
```bash
uv pip install -e . --prerelease=allow -f "https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html"
```
**With Conda**:
Install `tensordict` from `conda-forge` channel.
```sh
conda install -c conda-forge tensordict
```
## Citation
If you're using TensorDict, please refer to this BibTeX entry to cite this work:
```
@misc{bou2023torchrl,
title={TorchRL: A data-driven decision-making library for PyTorch},
author={Albert Bou and Matteo Bettini and Sebastian Dittert and Vikash Kumar and Shagun Sodhani and Xiaomeng Yang and Gianni De Fabritiis and Vincent Moens},
year={2023},
eprint={2306.00577},
archivePrefix={arXiv},
primaryClass={cs.LG}
}
```
## Disclaimer
TensorDict is at the *beta*-stage, meaning that there may be bc-breaking changes introduced, but
they should come with a warranty.
Hopefully these should not happen too often, as the current roadmap mostly
involves adding new features and building compatibility with the broader
PyTorch ecosystem.
## License
TensorDict is licensed under the MIT License. See [LICENSE](LICENSE) for details.
| text/markdown | null | Vincent Moens <vincentmoens@gmail.com> | null | null | BSD | null | [
"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",
"Development Status :: 4 - Beta"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"torch",
"numpy",
"cloudpickle",
"packaging",
"importlib_metadata",
"orjson; python_version < \"3.13\"",
"pyvers<0.3.0,>=0.2.0",
"pytest; extra == \"tests\"",
"pyyaml; extra == \"tests\"",
"pytest-instafail; extra == \"tests\"",
"pytest-rerunfailures; extra == \"tests\"",
"pytest-benchmark; extra == \"tests\"",
"h5py>=3.8; extra == \"h5\"",
"pybind11>=2.13; extra == \"dev\"",
"ninja; extra == \"dev\"",
"mypy>=1.0.0; extra == \"typecheck\"",
"onnx; extra == \"onnx\"",
"onnxscript; extra == \"onnx\"",
"onnxruntime; extra == \"onnx\""
] | [] | [] | [] | [
"homepage, https://github.com/pytorch/tensordict"
] | twine/6.2.0 CPython/3.12.10 | 2026-02-20T14:10:30.315147 | tensordict_nightly-2026.2.20-cp311-cp311-win_amd64.whl | 564,546 | c6/80/cea3a60026467f352bf69182b481b888a89417666744c6c5260c385bdc22/tensordict_nightly-2026.2.20-cp311-cp311-win_amd64.whl | cp311 | bdist_wheel | null | false | 5bba67f798ebd84be14c9758623dc72d | 075b56de062f3cc8a9c0cb28b9a7ce645110bc797ace190c0cb21301eadc3c0f | c680cea3a60026467f352bf69182b481b888a89417666744c6c5260c385bdc22 | null | [
"LICENSE"
] | 1,094 |
2.4 | cect | 0.2.7 | C. elegans Connectome Toolbox | # _C. elegans_ Connectome Toolbox
**Please note: this is a <u>Work in Progress</u>! Please contact padraig -at- openworm.org if you are interested in contributing to this work.**
Information on published connectomics data related to _C. elegans_.
See live site at: https://openworm.org/ConnectomeToolbox
| text/markdown | OpenWorm contributors | p.gleeson@gmail.com | Padraig Gleeson | p.gleeson@gmail.com | LGPLv3 | null | [
"Intended Audience :: Science/Research",
"License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
"Natural Language :: English",
"Operating System :: OS Independent",
"Topic :: Scientific/Engineering",
"Intended Audience :: Science/Research",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"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",
"Topic :: Software Development",
"Typing :: Typed"
] | [] | https://github.com/openworm/ConnectomeToolbox | null | >=3.7 | [] | [] | [] | [
"numpy<2.4",
"xlrd",
"openpyxl",
"wormneuroatlas",
"networkx",
"hiveplotlib<=0.25.1",
"webcolors",
"pyneuroml",
"pytest; extra == \"test\"",
"pytest-benchmark; extra == \"test\"",
"pytest-mock; extra == \"test\"",
"typing_extensions; python_version < \"3.8\" and extra == \"test\"",
"pandas; extra == \"docs\"",
"tabulate; extra == \"docs\"",
"mkdocs; extra == \"docs\"",
"mkdocs-material; extra == \"docs\"",
"mkdocs-plotly-plugin; extra == \"docs\"",
"mkdocs-charts-plugin; extra == \"docs\"",
"mkdocs-autoapi[python]>=0.3.1; extra == \"docs\"",
"mkdocs-jupyter; extra == \"docs\"",
"plotly<6.0.0; extra == \"docs\"",
"kaleido<0.4; extra == \"docs\"",
"flake8; extra == \"dev\"",
"cect[test]; extra == \"dev\"",
"pre-commit; extra == \"dev\"",
"tabulate; extra == \"dev\"",
"ruff; extra == \"dev\"",
"cect[test]; extra == \"all\"",
"cect[docs]; extra == \"all\"",
"cect[dev]; extra == \"all\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:10:23.719684 | cect-0.2.7.tar.gz | 5,657,142 | 1d/ed/69c68fa6f3f0bc031f8e91c6713973ef337cad7a7d0a14e4f9565c165b58/cect-0.2.7.tar.gz | source | sdist | null | false | 800cdf9cc7aefc7e7cee6c81fa22c0db | ed3d7aa555c309964489a98eb54b203a156f04b451aedebcef4d17fb3bcce877 | 1ded69c68fa6f3f0bc031f8e91c6713973ef337cad7a7d0a14e4f9565c165b58 | null | [
"LICENSE"
] | 262 |
2.4 | aieng-platform-onboard | 0.6.0 | CLI tool for onboarding participants to AI Engineering bootcamps | # AI Engineering Platform
----------------------------------------------------------------------------------------
[](https://pypi.org/project/aieng-platform-onboard)
[](https://github.com/VectorInstitute/aieng-platform/actions/workflows/code_checks.yml)
[](https://github.com/VectorInstitute/aieng-platform/actions/workflows/unit_tests.yml)
[](https://github.com/VectorInstitute/aieng-platform/actions/workflows/docs.yml)
[](https://codecov.io/github/VectorInstitute/aieng-platform)
[](https://img.shields.io/github/license/VectorInstitute/aieng-platform)
Infrastructure and tooling for AI Engineering bootcamps, providing secure, isolated development environments and automated participant onboarding.
## Overview
This platform consists of the following components:
1. **Coder Deployment** - Containerized development environments supported by [Coder](https://coder.com)
2. **Participant Onboarding System** - Secure, automated participant onboarding
---
## 1. Coder Deployment for GCP
The `coder` folder contains all resources needed to deploy a [Coder](https://coder.com) instance on Google Cloud Platform (GCP), along with reusable workspace templates and Docker images for the workspace environment.
### Structure
- **deploy/** - Terraform scripts and startup automation for provisioning the Coder server on a GCP VM
- **docker/** - Dockerfiles and guides for building custom images used by Coder workspace templates
- **templates/** - Coder workspace templates for reproducible, containerized development environments on GCP
### Usage
1. **Provision Coder on GCP** - Follow the steps in [`coder/deploy/README.md`](coder/deploy/README.md)
2. **Build and Push Docker Images** - See [`coder/docker/README.md`](coder/docker/README.md)
3. **Push Workspace Templates** - See [`coder/templates/README.md`](coder/templates/README.md)
---
## 2. Participant Onboarding System
Automated system for securely distributing team-specific API keys to bootcamp participants using Firebase Authentication and Firestore.
### Features
- **Secure Authentication** - Firebase custom tokens with per-participant access
- **Team Isolation** - Firestore security rules enforce team-level data separation
- **Automated Onboarding** - One-command setup for participants
- **API Key Management** - Automated generation and distribution of API keys
### Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ Admin Phase │
├─────────────────────────────────────────────────────────────────┤
│ 1. Setup teams and participants in Firestore │
│ 2. Generate team-specific API keys and shared keys │
│ 3. Add users to github AI-Engineering-Platform org │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Participant Phase │
├─────────────────────────────────────────────────────────────────┤
│ 1. Run onboarding script in Coder workspace │
│ 2. Script authenticates using token server │
│ 3. Fetches team-specific API keys (security rules enforced) │
│ 4. Creates .env file with all credentials │
│ 5. Runs integration tests to verify keys, marks onboard status │
└─────────────────────────────────────────────────────────────────┘
```
---
| text/markdown | null | Vector AI Engineering <ai_engineering@vectorinstitute.ai> | null | null | null | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"authlib==1.6.6",
"cryptography>=46.0.5",
"filelock==3.20.3",
"firebase-admin>=6.5.0",
"google-auth>=2.29.0",
"google-cloud-firestore>=2.18.0",
"google-cloud-secret-manager>=2.20.0",
"google-cloud-storage",
"openai>=1.0.0",
"pandas>=2.3.3",
"python-dotenv>=1.0.0",
"requests>=2.31.0",
"rich>=13.0.0",
"urllib3==2.6.3",
"virtualenv==20.36.1",
"weaviate-client>=4.0.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:10:19.440950 | aieng_platform_onboard-0.6.0.tar.gz | 34,820 | f5/b6/57cd7a3c54c1a6216a4d155d6a7e82180e9f161b3feba8c40fc6702ebd31/aieng_platform_onboard-0.6.0.tar.gz | source | sdist | null | false | f01d62f6cff9079ea5c7292684272f8c | 2965471b2b5aef7f2950639d8af2759307dc9b883b26846c53b3c3865954657e | f5b657cd7a3c54c1a6216a4d155d6a7e82180e9f161b3feba8c40fc6702ebd31 | Apache-2.0 | [
"LICENSE.md"
] | 249 |
2.3 | janus-core | 0.8.7 | Tools for machine learnt interatomic potentials | # `janus-core`
![logo][logo]
[![PyPI version][pypi-badge]][pypi-link]
[![Python versions][python-badge]][python-link]
[![Build Status][ci-badge]][ci-link]
[![Coverage Status][cov-badge]][cov-link]
[![Docs status][docs-badge]][docs-link]
[![License][license-badge]][license-link]
[![DOI][doi-badge]][doi-link]
Tools for machine learnt interatomic potentials
## Contents
- [Getting started](#getting-started)
- [Features](#features)
- [Python interface](#python-interface)
- [Command line interface](#command-line-interface)
- [Docker/Podman images](#dockerpodman-images)
- [Development](#development)
- [License](#license)
- [Funding](#funding)
## Getting started
### Dependencies
All required and optional dependencies can be found in [pyproject.toml](pyproject.toml).
### Installation
The latest stable release of `janus-core`, including its dependencies, can be installed from PyPI by running:
```
python3 -m pip install janus-core
```
To get all the latest changes, `janus-core` can also be installed from GitHub:
```
python3 -m pip install git+https://github.com/stfc/janus-core.git
```
By default, no machine learnt interatomic potentials (MLIPs) will be installed with `janus-core`. These can be installed separately, or as `extras`.
For example, to install MACE, CHGNet, and SevenNet, run:
```python
python3 -m pip install janus-core[mace,chgnet,sevennet]
```
> [!WARNING]
> We are unable to support for automatic installation of all combinations of MLIPs, or MLIPs on all platforms.
> Please refer to the [installation documentation](https://stfc.github.io/janus-core/user_guide/installation.html)
> for more details.
To install all MLIPs currently compatible with MACE, run:
```python
python3 -m pip install janus-core[all]
```
Individual `extras` are listed in [Getting Started](https://stfc.github.io/janus-core/user_guide/get_started.html#installation), as well as in [pyproject.toml](pyproject.toml) under `[project.optional-dependencies]`.
### Further help
Please see [Getting Started](https://stfc.github.io/janus-core/user_guide/get_started.html),
as well as guides for janus-core's [Python](https://stfc.github.io/janus-core/user_guide/python.html)
and [command line](https://stfc.github.io/janus-core/user_guide/command_line.html) interfaces,
for additional information, or [open an issue](https://github.com/stfc/janus-core/issues/new) if something doesn't seem right.
## Features
Unless stated otherwise, MLIP calculators and calculations rely heavily on [ASE](https://ase-lib.org).
Current and planned features include:
- [x] Support for multiple MLIPs
- MACE
- M3GNet
- CHGNet
- ALIGNN
- SevenNet
- NequIP
- DPA3
- Orb
- MatterSim
- GRACE
- EquiformerV2
- eSEN
- UMA
- PET-MAD
- [x] Single point calculations
- [x] Geometry optimisation
- [x] Molecular Dynamics
- NVE
- NVT (Langevin(Eijnden/Ciccotti flavour) and Nosé-Hoover (Melchionna flavour))
- NPT (Nosé-Hoover (Melchiona flavour))
- [x] Nudged Elastic Band
- [x] Phonons
- Phonopy
- [x] Equation of State
- [x] Training ML potentials
- MACE
- Nequip
- [x] Fine-tuning MLIPs
- MACE
- Nequip
- [x] MLIP descriptors
- MACE
- [x] Data preprocessing
- MACE
- [x] Rare events simulations
- PLUMED
- [x] Elasticity
## Python interface
Calculations can also be run through the Python interface. For example, running:
```python
from janus_core.calculations.single_point import SinglePoint
single_point = SinglePoint(
struct="tests/data/NaCl.cif",
arch="mace_mp",
model="tests/models/mace_mp_small.model",
)
results = single_point.run()
print(results)
```
will read the NaCl structure file and attach the MACE-MP (medium) calculator, before calculating and printing the energy, forces, and stress.
### Tutorials
Jupyter Notebook tutorials illustrating the use of currently available calculations can
be found in the [Python tutorials](docs/source/tutorials/python) documentation
directory. This currently includes examples for:
- [Single Point](docs/source/tutorials/python/single_point.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/single_point.ipynb)
- [Geometry Optimization](docs/source/tutorials/python/geom_opt.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/geom_opt.ipynb)
- [Molecular Dynamics](docs/source/tutorials/python/md.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/md.ipynb)
- [Equation of State](docs/source/tutorials/python/eos.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/eos.ipynb)
- [Phonons](docs/source/tutorials/python/phonons.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/phonons.ipynb)
- [Nudged Elastic Band](docs/source/tutorials/python/neb.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/neb.ipynb)
- [Elasticity](docs/source/tutorials/python/elasticity.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/python/elasticity.ipynb)
### Calculation outputs
By default, calculations performed will modify the underlying [ase.Atoms](https://ase-lib.org/ase/atoms.html) object
to store information in the `Atoms.info` and `Atoms.arrays` dictionaries about the MLIP used.
Additional dictionary keys include `arch`, corresponding to the MLIP architecture used,
and `model`, corresponding to the model path, name or label.
Results from the MLIP calculator, which are typically stored in `Atoms.calc.results`, will also, by default,
be copied to these dictionaries, prefixed by the MLIP `arch`.
For example:
```python
from janus_core.calculations.single_point import SinglePoint
single_point = SinglePoint(
struct="tests/data/NaCl.cif",
arch="mace_mp",
model="tests/models/mace_mp_small.model",
)
single_point.run()
print(single_point.struct.info)
```
will return
```python
{
'spacegroup': Spacegroup(1, setting=1),
'unit_cell': 'conventional',
'occupancy': {'0': {'Na': 1.0}, '1': {'Cl': 1.0}, '2': {'Na': 1.0}, '3': {'Cl': 1.0}, '4': {'Na': 1.0}, '5': {'Cl': 1.0}, '6': {'Na': 1.0}, '7': {'Cl': 1.0}},
'model': 'tests/models/mace_mp_small.model',
'arch': 'mace_mp',
'mace_mp_energy': -27.035127799332745,
'mace_mp_stress': array([-4.78327600e-03, -4.78327600e-03, -4.78327600e-03, 1.08000967e-19, -2.74004242e-19, -2.04504710e-19]),
'system_name': 'NaCl',
}
```
> [!NOTE]
> If running calculations with multiple MLIPs, `arch` and `mlip_model` will be overwritten with the most recent MLIP information.
> Results labelled by the architecture (e.g. `mace_mp_energy`) will be saved between MLIPs,
> unless the same `arch` is chosen, in which case these values will also be overwritten.
This is also the case the calculations performed using the CLI, with the same information written to extxyz output files.
> [!TIP]
> For complete provenance tracking, calculations and training can be run using the [aiida-mlip](https://github.com/stfc/aiida-mlip/) AiiDA plugin.
## Command line interface
All supported MLIP calculations are accessible through subcommands of the `janus` command line tool, which is installed with the package:
```shell
janus singlepoint
janus geomopt
janus md
janus phonons
janus eos
janus neb
janus train
janus descriptors
janus preprocess
janus elasticity
```
For example, a single point calcuation (using the [MACE-MP](https://github.com/ACEsuit/mace-mp) "small" force-field) can be performed by running:
```shell
janus singlepoint --struct tests/data/NaCl.cif --arch mace_mp --model small
```
A description of each subcommand, as well as valid options, can be listed using the `--help` option. For example,
```shell
janus singlepoint --help
```
prints the following:
```shell
Usage: janus singlepoint [OPTIONS]
Perform single point calculations and save to file.
╭─ Options ───────────────────────────────────────────────────────────────────────────╮
│ --config TEXT Path to configuration file. │
│ --help Show this message and exit. │
╰─────────────────────────────────────────────────────────────────────────────────────╯
╭─ MLIP calculator ───────────────────────────────────────────────────────────────────╮
│ * --arch [mace|mace_mp|mace_off|m3gne MLIP architecture to use for │
│ t|chgnet|alignn|sevennet|neq calculations. │
│ uip|dpa3|orb|mattersim|grace [required] │
│ |esen|equiformer|pet_mad|uma │
│ |mace_omol] │
│ --device [cpu|cuda|mps|xpu] Device to run calculations │
│ on. │
│ [default: cpu] │
│ --model TEXT MLIP model name, or path to │
│ model. │
│ --calc-kwargs DICT Keyword arguments to pass to │
│ selected calculator. Must be │
│ passed as a dictionary │
│ wrapped in quotes, e.g. │
│ "{'key': value}". │
╰─────────────────────────────────────────────────────────────────────────────────────╯
╭─ Calculation ───────────────────────────────────────────────────────────────────────╮
│ * --struct PATH Path of structure to simulate. │
│ [required] │
│ --properties [energy|stress|forces|hessia Properties to calculate. If │
│ n] not specified, 'energy', │
│ 'forces' and 'stress' will be │
│ returned. │
│ --out PATH Path to save structure with │
│ calculated results. Default is │
│ inferred from `file_prefix`. │
╰─────────────────────────────────────────────────────────────────────────────────────╯
╭─ Structure I/O ─────────────────────────────────────────────────────────────────────╮
│ --file-prefix PATH Prefix for output files, including directories. Default │
│ directory is ./janus_results, and default filename │
│ prefix is inferred from the input stucture filename. │
│ --read-kwargs DICT Keyword arguments to pass to ase.io.read. Must be │
│ passed as a dictionary wrapped in quotes, e.g. "{'key': │
│ value}". By default, read_kwargs['index'] = ':', so all │
│ structures are read. │
│ --write-kwargs DICT Keyword arguments to pass to ase.io.write when saving │
│ any structures. Must be passed as a dictionary wrapped │
│ in quotes, e.g. "{'key': value}". │
╰─────────────────────────────────────────────────────────────────────────────────────╯
╭─ Logging/summary ───────────────────────────────────────────────────────────────────╮
│ --log PATH Path to save logs to. Default is │
│ inferred from `file_prefix` │
│ --tracker --no-tracker Whether to save carbon emissions of │
│ calculation │
│ [default: tracker] │
│ --summary PATH Path to save summary of inputs, │
│ start/end time, and carbon emissions. │
│ Default is inferred from │
│ `file_prefix`. │
│ --progress-bar --no-progress-bar Whether to show progress bar. │
│ [default: progress-bar] │
╰─────────────────────────────────────────────────────────────────────────────────────╯
```
Please see the [user guide](https://stfc.github.io/janus-core/user_guide/command_line.html) for examples of each subcommand.
### Tutorials
Jupyter Notebook tutorials illustrating the use of currently available calculations can
be found in the [CLI tutorials](docs/source/tutorials/cli) documentation directory.
This currently includes examples for:
- [Single Point](docs/source/tutorials/cli/singlepoint.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/cli/singlepoint.ipynb)
- [Geometry Optimization](docs/source/tutorials/cli/geomopt.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/cli/geomopt.ipynb)
- [Molecular Dynamics](docs/source/tutorials/cli/md.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/cli/md.ipynb)
- [Phonons](docs/source/tutorials/cli/phonons.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/cli/phonons.ipynb)
- [Nudged Elastic Band](docs/source/tutorials/cli/neb.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/cli/neb.ipynb)
- [Elasticity](docs/source/tutorials/cli/elasticity.ipynb) [](https://colab.research.google.com/github/stfc/janus-core/blob/main/docs/source/tutorials/cli/elasticity.ipynb)
### Using configuration files
Default values for all command line options may be specifed through a Yaml 1.1 formatted configuration file by adding the `--config` option. If an option is present in both the command line and configuration file, the command line value takes precedence.
For example, with the following configuration file and command:
```yaml
struct: "NaCl.cif"
properties:
- "energy"
out: "NaCl-results.extxyz"
arch: mace_mp
model-path: medium
calc-kwargs:
dispersion: True
```
```shell
janus singlepoint --arch mace_mp --struct KCl.cif --out KCl-results.cif --config config.yml
```
This will run a singlepoint energy calculation on `KCl.cif` using the [MACE-MP](https://github.com/ACEsuit/mace-mp) "medium" force-field, saving the results to `KCl-results.cif`.
> [!NOTE]
> `properties` must be passed as a Yaml list, as above, not as a string.
Minimal and full example configuration files for all calculations can be found
[here](https://stfc.github.io/janus-core/examples/index.html).
## Docker/Podman images
You can use `janus_core` in a JupyterHub or marimo environment using [docker](https://www.docker.com) or [podman](https://podman.io/). We provide regularly updated docker/podman images, which can be dowloaded by running:
```shell
docker pull ghcr.io/stfc/janus-core/jupyter:amd64-latest
docker pull ghcr.io/stfc/janus-core/marimo:amd64-latest
```
or using podman
```shell
podman pull ghcr.io/stfc/janus-core/jupyter-amd64:latest
podman pull ghcr.io/stfc/janus-core/marimo-amd64:latest
```
for amd64 architecture, if you require arm64 replace amd64 with arm64 above, and next instructions.
To start, for marimo run:
```shell
podman run --rm --security-opt seccomp=unconfined -p 8842:8842 ghcr.io/stfc/janus-core/marimo:amd64-latest
```
or for JupyterHub, run:
```
podman run --rm --security-opt seccomp=unconfined -p 8888:8888 ghcr.io/stfc/janus-core/jupyter:amd64-latest
```
For more details on how to share your filesystem and so on you can refer to this documentation: https://summer.ccp5.ac.uk/introduction.html#run-locally.
## Development
We recommend installing uv for dependency management when developing for `janus-core`:
1. Install [uv](https://docs.astral.sh/uv/getting-started/installation)
2. Install `janus-core` with dependencies in a virtual environment:
```shell
git clone https://github.com/stfc/janus-core
cd janus-core
uv sync --extra all # Create a virtual environment and install dependencies
source .venv/bin/activate
pre-commit install # Install pre-commit hooks
pytest -v # Discover and run all tests
```
## License
[BSD 3-Clause License](LICENSE)
## Funding
Contributors to this project were funded by
[](https://www.psdi.ac.uk/)
[<img src="docs/source/images/alc.svg" width="200" height="100" />](https://adalovelacecentre.ac.uk/)
[](https://www.scd.stfc.ac.uk/Pages/CoSeC.aspx)
[ci-badge]: https://github.com/stfc/janus-core/actions/workflows/ci.yml/badge.svg?branch=main
[ci-link]: https://github.com/stfc/janus-core/actions
[cov-badge]: https://coveralls.io/repos/github/stfc/janus-core/badge.svg?branch=main
[cov-link]: https://coveralls.io/github/stfc/janus-core?branch=main
[docs-badge]: https://img.shields.io/github/actions/workflow/status/stfc/janus-core/publish-on-pypi.yml?label=docs
[docs-link]: https://stfc.github.io/janus-core/
[pypi-badge]: https://badge.fury.io/py/janus-core.svg
[pypi-link]: https://pypi.org/project/janus-core/
[python-badge]: https://img.shields.io/pypi/pyversions/janus-core.svg
[python-link]: https://pypi.org/project/janus-core/
[license-badge]: https://img.shields.io/badge/License-BSD_3--Clause-blue.svg
[license-link]: https://opensource.org/licenses/BSD-3-Clause
[doi-link]: https://zenodo.org/badge/latestdoi/754081470
[doi-badge]: https://zenodo.org/badge/754081470.svg
[logo]: https://raw.githubusercontent.com/stfc/janus-core/main/docs/source/images/janus-core-100.png
| text/markdown | Elliott Kasoar, Patrick Austin, Harvey Devereux, Kieran Harris, David Mason, Jacob Wilkins, Federica Zanca, Alin M. Elena | null | null | null | null | null | [
"Programming Language :: Python",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Development Status :: 3 - Alpha"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"ase<4.0,>=3.25",
"click<9,>=8.2.1",
"codecarbon<4.0.0,>=3.0.7",
"numpy<3.0.0,>=1.26.4",
"phonopy<2.48,>=2.39.0",
"pymatgen>=2025.1.24",
"pyyaml<7.0.0,>=6.0.1",
"rich<14.0.0,>=13.9.1",
"seekpath<3.0.0,>=1.9.7",
"spglib<3.0.0,>=2.3.0",
"typer<1.0.0,>=0.19.1",
"typer-config<2.0.0,>=1.4.2",
"alignn==2024.5.27; sys_platform != \"win32\" and extra == \"alignn\"",
"torch==2.2; sys_platform != \"win32\" and extra == \"alignn\"",
"torchdata==0.7.1; sys_platform != \"win32\" and extra == \"alignn\"",
"janus-core[chgnet]; extra == \"all\"",
"janus-core[grace]; extra == \"all\"",
"janus-core[d3]; extra == \"all\"",
"janus-core[mace]; extra == \"all\"",
"janus-core[orb]; extra == \"all\"",
"janus-core[pet-mad]; extra == \"all\"",
"janus-core[plumed]; extra == \"all\"",
"janus-core[visualise]; extra == \"all\"",
"chgnet==0.4.2; extra == \"chgnet\"",
"torch-dftd==0.5.1; extra == \"d3\"",
"deepmd-kit==3.1.0; extra == \"dpa3\"",
"fairchem-core==1.10.0; extra == \"fairchem-1\"",
"scipy<1.17.0; extra == \"fairchem-1\"",
"fairchem-core==2.12.0; extra == \"fairchem-2\"",
"setuptools<82; extra == \"fairchem-2\"",
"tensorpotential==0.5.1; extra == \"grace\"",
"matgl==1.1.3; sys_platform != \"win32\" and extra == \"m3gnet\"",
"torch==2.2; sys_platform != \"win32\" and extra == \"m3gnet\"",
"torchdata==0.7.1; sys_platform != \"win32\" and extra == \"m3gnet\"",
"ase<=3.26.0; extra == \"m3gnet\"",
"mace-torch==0.3.14; extra == \"mace\"",
"janus-core[d3]; extra == \"mace\"",
"mattersim==1.1.2; sys_platform != \"win32\" and extra == \"mattersim\"",
"nequip==0.14.0; extra == \"nequip\"",
"orb-models==0.5.5; sys_platform != \"win32\" and extra == \"orb\"",
"pet-mad==1.3.1; sys_platform != \"win32\" and extra == \"pet-mad\"",
"plumed<3.0.0,>=2.9.0; sys_platform != \"win32\" and extra == \"plumed\"",
"sevenn==0.11.2.post1; extra == \"sevennet\"",
"weas-widget<0.2,>=0.1.26; extra == \"visualise\""
] | [] | [] | [] | [
"Documentation, https://stfc.github.io/janus-core/",
"Repository, https://github.com/stfc/janus-core/"
] | 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-20T14:09:39.281042 | janus_core-0.8.7.tar.gz | 82,035 | 42/d4/121532d1daf76870f4d7bbf8bcfa06e1b7f3b10c1aaedd0a521a2be3245e/janus_core-0.8.7.tar.gz | source | sdist | null | false | e3d318cbb3b7fcfb534ce27f9c9050ab | 82eb8f2ebfc954875e2725e7d96e1e84f18259e7a21c7aa0b55d39ccb2542f3f | 42d4121532d1daf76870f4d7bbf8bcfa06e1b7f3b10c1aaedd0a521a2be3245e | null | [] | 239 |
2.4 | mindgard | 0.107.1 | Test your AI model's security without leaving your terminal. | <h1 align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/Mindgard/public-resources/blob/main/mindgard-dark.svg?raw=true">
<source media="(prefers-color-scheme: light)" srcset="https://github.com/Mindgard/public-resources/blob/main/mindgard.svg?raw=true">
<img src="https://github.com/Mindgard/public-resources/blob/main/mindgard.svg?raw=true"/>
</picture>
</h1>
# Mindgard CLI
## Securing AI Models.
#### Continuous automated red teaming platform.
Identify & remediate your AI models' security risks with Mindgard's market leading attack library. Mindgard covers many threats including:
✅ Jailbreaks
✅ Prompt Injection
✅ Model Inversion
✅ Extraction
✅ Poisoning
✅ Evasion
✅ Membership Inference
Mindgard CLI is fully integrated with Mindgard's platform to help you identify and triage threats, select remediations, and track your security posture over time.
<h2 align="center">
<img src="https://github.com/Mindgard/public-resources/blob/main/videos/cli/clijuly.mid.gif?raw=true"/>
</h2>
Test continuously in your MLOps pipeline to identify model posture changes from customisation activities including prompt engineering, RAG, fine-tuning, and pre-training.
Table of Contents
-----------------
* [🚀 Install](#Install)
* [✅ Testing demo models](#Tests)
* [✅ Testing your models](#TestCustom)
* [📝 Documentation](#Documentation)
* [🚦 Using in an MLOps pipeline](#MLops)
<a id="Install"></a>
## 🚀 Install Mindgard CLI
`pip install mindgard` or `pip install --upgrade mindgard` to update to the latest version
### 🔑 Login
`mindgard login`
If you are a mindgard enterprise customer, login to your enterprise instance using the command:
`mindgard login --instance <name>`
Replace `<name>` with the instance name provided by your Mindgard representative. This instance name identifies your SaaS, private tenant, or on-prem deployment.
### 🥞🥞 Bulk Deployment
To perform a bulk deployment:
1. **Login and Configure**: Login and Configure the Mindgard CLI on a test workstation
2. **Provision Files**: Provision the files contained in the `.mindgard/` folder within your home directory to your target instances via your preferred deployment mechanism.
The `.mindgard/` folder contains:
* `token.txt`: A JWT for authentication.
* `instance.txt` (enterprise only): Custom instance configuration for your SaaS or private tenant.
<a id="Tests"></a>
## ✅ Test a mindgard hosted model
```
mindgard sandbox
```
<a id="TestCustom"></a>
## ✅ Test your own models
Our testing infrastructure can be pointed at your models using the CLI.
Testing an external model uses the `test` command to evaluate your LLMs.
`mindgard test <name> --url <url> <other settings>`
### LLMs
```
mindgard test my-model-name \
--url http://127.0.0.1/infer \ # url to test
--selector '["response"]' \ # JSON selector to match the textual response
--request-template '{"prompt": "[INST] {system_prompt} {prompt} [/INST]"}' \ # how to format the system prompt and prompt in the API request
--system-prompt 'respond with hello' # system prompt to test the model with
```
### Validate model is online before launching tests
A preflight check is run automatically when submitting a new test, but if you want to invoke it manually:
`mindgard validate --url <url> <other settings>`
```
mindgard validate \
--url http://127.0.0.1/infer \ # url to test
--selector '["response"]' \ # JSON selector to match the textual response
--request-template '{"prompt": "[INST] {system_prompt} {prompt} [/INST]"}' \ # how to format the system prompt and prompt in the API request
--system-prompt 'respond with hello' # system prompt to test the model with
```
<a id="Documentation"></a>
### 📝 Documentation - [Documentation for Running a test using CLI](https://docs.mindgard.ai/user-guide/testing-via-cli)
### 📋 Using a Configuration File
You can specify the settings for the `mindgard test` command in a TOML configuration file. This allows you to manage your settings in a more structured way and avoid passing them as command-line arguments.
Then run: `mindgard test --config-file mymodel.toml`
### Examples
There are examples of what the configuration file (`mymodel.toml`) might look like <a href="https://docs.mindgard.ai/user-guide/test-configuration-examples" >in the Mindgard docs.</a>
Here are two examples:
#### Targeting OpenAI
This example uses the built in preset settings for openai. Presets exist for `openai`, `huggingface`, and `anthropic`
```toml
target = "my-model-name"
preset = "openai"
api_key= "CHANGE_THIS_TO_YOUR_OPENAI_API_KEY"
system-prompt = '''
You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.
'''
```
You will need to substitute your own `api_key` value.
The `target` setting is an identifier for the model you are testing within the Mindgard platform, tests for the same model will be grouped and traceable over time.
Altering the `system-prompt` enables you to compare results with different system prompts in use. Some of Mindgard's tests assess the efficacy of your system prompt.
Any of these settings can also be passed as command line arguments. e.g. `mindgard test my-model-name --system-prompt 'You are...'`. This may be useful to pass in a dynamic value for any of these settings.
#### Targeting a more general model API without a suitable preset
This example shows how you might test OpenAI if the preset did not exist. With the `request_template` and `selector` settings you can interface with any JSON API.
```toml
target = "my-model-name"
url = "https://api.openai.com/v1/chat/completions"
request_template = '''
{
"messages": [
{"role": "system", "content": "{system_prompt}"},
{"role": "user", "content": "{prompt}"}],
"model": "gpt-3.5-turbo",
"temperature": 0.0,
"max_tokens": 1024
}
'''
selector = '''
choices[0].message.content
'''
headers = "Authorization: Bearer CHANGE_THIS_TO_YOUR_OPENAI_API_KEY"
system_prompt = '''
You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.
'''
```
The `request_template` setting specifies how to structure an outgoing message to the model. You will need to specify the `{system_prompt}` and `{prompt}` placeholders so that Mindgard knows how to pass this information to your custom API.
The `url` setting should point to an inference endpoint for your model under test. Mindgard will POST messages here formatted by the above `request_template` setting.
The `selector` setting is a JSON selector and specifies how to extract the model's response from the API response.
The `headers` setting allows you to specify a custom HTTP header to include with outgoing requests, for example to implement a custom authentication method.
<a id="custom_datasets"></a>
### Custom Dataset Generation
The CLI tool allows users to generate custom datasets for use in either the CLI, or the Burp suite extension.
It works by taking a 'seed prompt' which describes some kind of policy you want to generate dataset entries to test. The tool will generate a set of examples and save them to your machine as an output file.
```mindgard create dataset --seed-prompt "I am a car sales person and I dont want customers to game my chatbot to get free cars." --perspective nonspecific --tone neutral --num-entries 20 --output-filename dataset_20_entries.txt```
Which will generate:
```
I'm curious about the strategies people use to negotiate for a free car in sales.
It would be interesting to learn how others have successfully gotten discounts or free deals on cars.
I want to understand the tactics that some buyers might use to take advantage of salespeople.
I'm intrigued by the psychology behind customers who attempt to get something for nothing in car sales.
I’m interested in hearing some examples of customers who got creative in their negotiations for a car.
...
..
.
```
#### `--seed-prompt` (required)
A seed prompt representing a policy, for which a dataset encouraging violations of the policy will be generated.
For example: "The model should never generate harmful, unethical, or illegal content."
#### `--perspective` (optional)
The perspective to use while generating the dataset. This skews the dataset generation towards asking the same question, but through a historical, cultural, etc lens that may subvert a target model. Defaults to `nonspecific`.
#### `--tone` (optional)
The tone to use for the questions in the dataset. Defaults to `neutral`.
#### `--num_entries` (optional)
Number of dataset entries to generate. Provided number is a goal, but the LLM may generate more or less than requested. Defaults to `15`.
#### `--output-filename` (optional)
Name of the file the dataset will be stored in. Defaults to `mindgard_custom_dataset.txt`.
<a id="MLops"></a>
### 🚦 Using in an MLOps pipeline
The exit code of a test will be non-zero if the test identifies risks above your risk threshold. To override the default risk-threshold pass `--risk-threshold 50`. This will cause the CLI to exit with an non-zero exit status if the test's flagged event to total event ratio is >= the threshold.
See an example of this in action here: [https://github.com/Mindgard/mindgard-github-action-example](https://github.com/Mindgard/mindgard-github-action-example)
### 📋 Managing request load
You have the option to set the parallelism parameter which sets the maximum amount of requests you want to target your model concurrently. This enables you to protect your model from getting too many requests.
We require that your model responds within 60s so set parallelism accordingly (it should be less than the number of requests you can serve per minute).
Then run: `mindgard test --config-file mymodel.toml --parallelism X`
### 🐛 Debugging
You can provide the flag `mindgard --log-level=debug <command>` to get some more info out of whatever command you're running. On unix-like systems, `mindgard --log-level=debug test --config=<toml> --parallelism=5 2> stderr.log` will write stdout and stderr to file.
### Model Compatability Debugging
When running tests with `huggingface-openai` preset you may encounter compatibility issues. Some models, e.g. [llama2](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf), [mistral-7b-instruct](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2) are not fully compatible with the OpenAI system. This can manifest in Template errors which can be seen by setting `--log-level=debug`:
```
DEBUG Received 422 from provider: Template error: unknown method: string has no method named strip (in <string>:1)
DEBUG Received 422 from provider: Template error: syntax error: Conversation roles must alternate user/assistant/user/assistant/... (in <string>:1)
```
Try using the simpler `huggingface` preset, which provides more compatibility through manual configuration, but sacrifices chat completion support.
From our experience, newer versions of models have started including the correct jinja templates so will not require config adjustments.
## Acknowledgements.
We would like to thank and acknowledge various research works from the Adversarial Machine Learning community, which inspired and informed the development of several AI security tests accessible through Mindgard CLI.
Jiang, F., Xu, Z., Niu, L., Xiang, Z., Ramasubramanian, B., Li, B., & Poovendran, R. (2024). ArtPrompt: ASCII Art-based Jailbreak Attacks against Aligned LLMs. arXiv [Cs.CL]. Retrieved from http://arxiv.org/abs/2402.11753
Russinovich, M., Salem, A., & Eldan, R. (2024). Great, Now Write an Article About That: The Crescendo Multi-Turn LLM Jailbreak Attack. arXiv [Cs.CR]. Retrieved from http://arxiv.org/abs/2404.01833
Goodside, R. LLM Prompt Injection Via Invisible Instructions in Pasted Text, Retreved from https://x.com/goodside/status/1745511940351287394
Yuan, Y., Jiao, W., Wang, W., Huang, J.-T., He, P., Shi, S., & Tu, Z. (2024). GPT-4 Is Too Smart To Be Safe: Stealthy Chat with LLMs via Cipher. arXiv [Cs.CL]. Retrieved from http://arxiv.org/abs/2308.06463
| text/markdown | Mindgard | support@mindgard.ai | null | null | MIT | null | [
"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"
] | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"anthropic<0.80.0,>=0.79.0",
"auth0-python<5.0.0,>=4.7.1",
"azure-messaging-webpubsubclient<2.0.0,>=1.0.0",
"azure-messaging-webpubsubservice<2.0.0,>=1.0.1",
"httpx<0.28.0,>=0.27.0",
"jinja2<4.0.0,>=3.1.6",
"jsonpath-ng<2.0.0,>=1.6.1",
"openai<2.0.0,>=1.16.2",
"pydantic<3.0.0,>=2.11.10",
"ratelimit<3.0.0,>=2.2.1",
"requests<3.0.0,>=2.32.5",
"rich<14.0.0,>=13.7.1",
"tenacity<10.0.0,>=9.1.2",
"toml<0.11.0,>=0.10.2",
"transformers!=4.57.0,<5.0.0,>=4.56.0",
"typing_extensions<5.0.0,>=4.15.0",
"urllib3<3.0.0,>=2.5.0"
] | [] | [] | [] | [
"Homepage, https://github.com/Mindgard/cli",
"Issues, https://github.com/Mindgard/cli/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:09:31.766713 | mindgard-0.107.1.tar.gz | 62,225 | 71/13/988668cc96a7cebd27143a441554f4b6398c336815db8cf3a31a09cd6fa9/mindgard-0.107.1.tar.gz | source | sdist | null | false | 15f4e09f66b7158491a9145c8428c106 | 23b775441f5a4d6bfed06a4cbfb4717ee29fcc824315d6435dd922790268fa3c | 7113988668cc96a7cebd27143a441554f4b6398c336815db8cf3a31a09cd6fa9 | null | [
"LICENSE.txt"
] | 225 |
2.4 | nufftax | 0.4.0 | Pure JAX implementation of Non-Uniform FFT | <p align="center">
<img src="docs/_static/logo.png" alt="nufftax logo" width="200">
</p>
<p align="center">
<strong>Pure JAX implementation of the Non-Uniform Fast Fourier Transform (NUFFT)</strong>
</p>
<p align="center">
<a href="https://github.com/GragasLab/nufftax/actions/workflows/ci.yml"><img src="https://github.com/GragasLab/nufftax/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
<a href="https://nufftax.readthedocs.io"><img src="https://img.shields.io/badge/docs-online-blue.svg" alt="Documentation"></a>
<a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.12+-blue.svg" alt="Python 3.12+"></a>
<a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
</p>
---
<p align="center">
<img src="docs/_static/mri_example.png" alt="MRI reconstruction example" width="100%">
</p>
## Why nufftax?
A JAX package for NUFFT already exists: [jax-finufft](https://github.com/flatironinstitute/jax-finufft). However, it wraps the C++ FINUFFT library via Foreign Function Interface (FFI), exposing it through custom XLA calls. This approach can lead to:
- **Kernel fusion issues on GPU** — custom XLA calls act as optimization barriers, preventing XLA from fusing operations
- **CUDA version matching** — GPU support requires matching CUDA versions between JAX and the library
**nufftax** takes a different approach — pure JAX implementation:
- **Fully differentiable** — gradients w.r.t. both values *and* sample locations
- **Pure JAX** — works with `jit`, `grad`, `vmap`, `jvp`, `vjp` with no FFI barriers
- **GPU ready** — runs on CPU/GPU without code changes, benefits from XLA fusion
- **Pallas GPU kernels** — fused Triton spreading kernels with 5-75x speedups on A100/H100
- **All NUFFT types** — Type 1, 2, 3 in 1D, 2D, 3D
## JAX Transformation Support
| Transform | `jit` | `grad`/`vjp` | `jvp` | `vmap` |
|-----------|:-----:|:------------:|:-----:|:------:|
| **Type 1** (1D/2D/3D) | ✅ | ✅ | ✅ | ✅ |
| **Type 2** (1D/2D/3D) | ✅ | ✅ | ✅ | ✅ |
| **Type 3** (1D/2D/3D) | ✅ | ✅ | ✅ | ✅ |
**Differentiable inputs:**
- Type 1: `grad` w.r.t. `c` (strengths) and `x, y, z` (coordinates)
- Type 2: `grad` w.r.t. `f` (Fourier modes) and `x, y, z` (coordinates)
- Type 3: `grad` w.r.t. `c` (strengths), `x, y, z` (source coordinates), and `s, t, u` (target frequencies)
## GPU Acceleration
On GPU, nufftax automatically dispatches spreading and interpolation to fused [Pallas](https://docs.jax.dev/en/latest/pallas/index.html) (Triton) kernels when the problem is large enough. This avoids materializing O(M × nspread^d) intermediate tensors and uses atomic scatter-add for spreading.
| Operation | Backend | Speedup vs pure JAX |
|-----------|---------|---------------------|
| 1D spread | A100 | 5–67x (M ≥ 100K) |
| 1D spread | H100 | 4–75x (M ≥ 100K) |
| 2D spread | A100/H100 | 2–3x (M ≥ 100K) |
The dispatch is transparent — no code changes required. On CPU or for small problems, the pure JAX path is used.
## Installation
**CPU only:**
```bash
uv pip install nufftax
```
**With CUDA 12 GPU support:**
```bash
uv pip install "nufftax[cuda12]"
```
**Development install (from source):**
```bash
git clone https://github.com/GragasLab/nufftax.git
cd nufftax
uv pip install -e ".[dev]"
```
This installs test dependencies (`pytest`, `ruff`, `finufft` for comparison testing, `pre-commit`).
**Development install with CUDA 12:**
```bash
uv pip install -e ".[dev,cuda12]"
```
**With docs dependencies:**
```bash
uv pip install -e ".[docs]"
```
## Quick Example
```python
import jax
import jax.numpy as jnp
from nufftax import nufft1d1
# Irregular sample locations in [-pi, pi)
x = jnp.array([0.1, 0.7, 1.3, 2.1, -0.5])
c = jnp.array([1.0+0.5j, 0.3-0.2j, 0.8+0.1j, 0.2+0.4j, 0.5-0.3j])
# Compute Fourier modes
f = nufft1d1(x, c, n_modes=32, eps=1e-6)
# Differentiate through the transform
grad_c = jax.grad(lambda c: jnp.sum(jnp.abs(nufft1d1(x, c, n_modes=32)) ** 2))(c)
```
## Documentation
**[Read the full documentation →](https://nufftax.readthedocs.io)**
- [Quickstart](https://nufftax.readthedocs.io/en/latest/quickstart.html) — get running in 5 minutes
- [Concepts](https://nufftax.readthedocs.io/en/latest/concepts.html) — understand the mathematics
- [Tutorials](https://nufftax.readthedocs.io/en/latest/tutorials.html) — MRI reconstruction, spectral analysis, optimization
- [API Reference](https://nufftax.readthedocs.io/en/latest/api.html) — complete function reference
## License
MIT. Algorithm based on [FINUFFT](https://github.com/flatironinstitute/finufft) by the Flatiron Institute.
## Citation
If you use nufftax in your research, please cite:
```bibtex
@software{nufftax,
author = {Gragas and Oudoumanessah, Geoffroy and Iollo, Jacopo},
title = {nufftax: Pure JAX implementation of the Non-Uniform Fast Fourier Transform},
url = {https://github.com/GragasLab/nufftax},
year = {2026}
}
@article{finufft,
author = {Barnett, Alexander H. and Magland, Jeremy F. and af Klinteberg, Ludvig},
title = {A parallel non-uniform fast Fourier transform library based on an ``exponential of semicircle'' kernel},
journal = {SIAM J. Sci. Comput.},
volume = {41},
number = {5},
pages = {C479--C504},
year = {2019}
}
```
| text/markdown | Geoffroy Oudoumanessah, Jacopo Iollo | Gragas <contact@gragas.ai> | null | null | null | jax, fft, nufft, non-uniform, fourier-transform, autodiff | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Science/Research",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Scientific/Engineering :: Mathematics"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"jax>=0.4.0",
"numpy!=2.4.0,>=1.20",
"jax[cuda12]>=0.4.0; extra == \"cuda12\"",
"pytest>=7.0; extra == \"dev\"",
"pytest-cov; extra == \"dev\"",
"finufft>=2.0; extra == \"dev\"",
"ruff>=0.4.0; extra == \"dev\"",
"pre-commit>=3.0; extra == \"dev\"",
"sphinx>=7.0; extra == \"docs\"",
"sphinx-book-theme>=1.0; extra == \"docs\"",
"sphinx-autobuild>=2024.0; extra == \"docs\"",
"myst-nb>=1.0; extra == \"docs\"",
"sphinx-autodoc-typehints>=1.24; extra == \"docs\"",
"sphinx-design>=0.5; extra == \"docs\"",
"sphinx-copybutton>=0.5; extra == \"docs\"",
"sphinx-togglebutton>=0.3; extra == \"docs\"",
"matplotlib>=3.5; extra == \"docs\"",
"scipy>=1.9; extra == \"docs\""
] | [] | [] | [] | [
"Homepage, https://github.com/GragasLab/nufftax",
"Documentation, https://nufftax.readthedocs.io",
"Repository, https://github.com/GragasLab/nufftax"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:09:20.878409 | nufftax-0.4.0.tar.gz | 54,135 | f5/af/0462d99bc55244390e69b940049fb86289c441bfae847776b36e8999ee0c/nufftax-0.4.0.tar.gz | source | sdist | null | false | ac8b0ade9f68630fef80d71aeaea0810 | 3d54f25c28e162b5838341d1f86d6acb5baca10b607eaee950ce71b0313a5f19 | f5af0462d99bc55244390e69b940049fb86289c441bfae847776b36e8999ee0c | MIT | [
"LICENSE"
] | 216 |
2.4 | cornflow | 1.3.1rc2 | cornflow is an open source multi-solver optimization server with a REST API built using flask. | cornflow
=========
.. image:: https://github.com/baobabsoluciones/cornflow/workflows/build/badge.svg?style=svg
:target: https://github.com/baobabsoluciones/cornflow/actions
.. image:: https://github.com/baobabsoluciones/cornflow/workflows/docs/badge.svg?style=svg
:target: https://github.com/baobabsoluciones/cornflow/actions
.. image:: https://github.com/baobabsoluciones/cornflow/workflows/integration/badge.svg?style=svg
:target: https://github.com/baobabsoluciones/cornflow/actions
.. image:: https://img.shields.io/pypi/v/cornflow-client.svg?style=svg
:target: https://pypi.python.org/pypi/cornflow-client
.. image:: https://img.shields.io/pypi/pyversions/cornflow-client.svg?style=svg
:target: https://pypi.python.org/pypi/cornflow-client
.. image:: https://img.shields.io/badge/License-Apache2.0-blue
cornflow is an open source multi-solver optimization server with a REST API built using `flask <https://flask.palletsprojects.com>`_, `airflow <https://airflow.apache.org/>`_ and `pulp <https://coin-or.github.io/pulp/>`_.
While most deployment servers are based on the solving technique (MIP, CP, NLP, etc.), cornflow focuses on the optimization problems themselves. However, it does not impose any constraint on the type of problem and solution method to use.
With cornflow you can deploy a Traveling Salesman Problem solver next to a Knapsack solver or a Nurse Rostering Problem solver. As long as you describe the input and output data, you can upload any solution method for any problem and then use it with any data you want.
cornflow helps you formalize your problem by proposing development guidelines. It also provides a range of functionalities around your deployed solution method, namely:
* storage of users, instances, solutions and solution logs.
* deployment and maintenance of models, solvers and algorithms.
* scheduling of executions in remote machines.
* management of said executions: start, monitor, interrupt.
* centralizing of commercial licenses.
* scenario storage and comparison.
* user management, roles and groups.
.. contents:: **Table of Contents**
Installation instructions
-------------------------------
cornflow is tested with Ubuntu 20.04, python >= 3.8 and git.
Download the cornflow project and install requirements::
python3 -m venv venv
venv/bin/pip3 install cornflow
initialize the sqlite database::
source venv/bin/activate
export FLASK_APP=cornflow.app
export DATABASE_URL=sqlite:///cornflow.db
flask db upgrade
flask access_init
flask create_service_user -u airflow -e airflow_test@admin.com -p airflow_test_password
flask create_admin_user -u cornflow -e cornflow_admin@admin.com -p cornflow_admin_password
activate the virtual environment and run cornflow::
source venv/bin/activate
export FLASK_APP=cornflow.app
export SECRET_KEY=THISNEEDSTOBECHANGED
export DATABASE_URL=sqlite:///cornflow.db
export AIRFLOW_URL=http://127.0.0.1:8080/
export AIRFLOW_USER=airflow_user
export AIRFLOW_PWD=airflow_pwd
flask run
**cornflow needs a running installation of Airflow to operate and more configuration**. Check `the installation docs <https://baobabsoluciones.github.io/cornflow/main/install.html>`_ for more details on installing airflow, configuring the application and initializing the database.
Using cornflow to solve a PuLP model
---------------------------------------
We're going to test the cornflow server by using the `cornflow-client` and the `pulp` python package::
pip install cornflow-client pulp
Initialize the api client::
from cornflow_client import CornFlow
email = 'some_email@gmail.com'
pwd = 'Some_password1'
username = 'some_name'
client = CornFlow(url="http://127.0.0.1:5000")
Create a user::
config = dict(username=username, email=email, pwd=pwd)
client.sign_up(**config)
Log in::
client.login(username=username, pwd=pwd)
Prepare an instance::
import pulp
prob = pulp.LpProblem("test_export_dict_MIP", pulp.LpMinimize)
x = pulp.LpVariable("x", 0, 4)
y = pulp.LpVariable("y", -1, 1)
z = pulp.LpVariable("z", 0, None, pulp.LpInteger)
prob += x + 4 * y + 9 * z, "obj"
prob += x + y <= 5, "c1"
prob += x + z >= 10, "c2"
prob += -y + z == 7.5, "c3"
data = prob.to_dict()
insName = 'test_export_dict_MIP'
description = 'very small example'
Send instance::
instance = client.create_instance(data, name=insName, description=description, schema="solve_model_dag",)
Solve an instance::
config = dict(
solver = "PULP_CBC_CMD",
timeLimit = 10
)
execution = client.create_execution(
instance['id'], config, name='execution1', description='execution of a very small instance',
schema="solve_model_dag",
)
Check the status of an execution::
status = client.get_status(execution["id"])
print(status['state'])
# 1 means "finished correctly"
Retrieve a solution::
results = client.get_solution(execution['id'])
print(results['data'])
# returns a json with the solved pulp object
_vars, prob = pulp.LpProblem.from_dict(results['data'])
Retrieve the log of the solver::
log = client.get_log(execution['id'])
print(log['log'])
# json format of the solver log
Using cornflow to deploy a solution method
---------------------------------------------
To deploy a cornflow solution method, the following tasks need to be accomplished:
#. Create an Application for the new problem
#. Do a PR to a compatible repo linked to a server instance (e.g., like `this one <https://github.com/baobabsoluciones/cornflow>`_).
For more details on each part, check the `deployment guide <https://baobabsoluciones.github.io/cornflow/guides/deploy_solver.html>`_.
Using cornflow to solve a problem
-------------------------------------------
For this example we only need the cornflow_client package. We will test the graph-coloring demo defined `here <https://github.com/baobabsoluciones/cornflow-dags-public/tree/main/DAG/graph_coloring>`_. We will use the test server to solve it.
Initialize the api client::
from cornflow_client import CornFlow
email = 'readme@gmail.com'
pwd = 'some_password'
username = 'some_name'
client = CornFlow(url="https://devsm.cornflow.baobabsoluciones.app/")
client.login(username=username, pwd=pwd)
solve a graph coloring problem and get the solution::
data = dict(pairs=[dict(n1=0, n2=1), dict(n1=1, n2=2), dict(n1=1, n2=3)])
instance = client.create_instance(data, name='gc_4_1', description='very small gc problem', schema="graph_coloring")
config = dict()
execution = client.create_execution(
instance['id'], config, name='gc_4_1_exec', description='execution of very small gc problem',
schema="graph_coloring",
)
status = client.get_status(execution["id"])
print(status['state'])
solution = client.get_solution(execution["id"])
print(solution['data']['assignment'])
Running tests and coverage
------------------------------
Then you have to run the following commands::
export FLASK_ENV=testing
Finally you can run all the tests with the following command::
python -m unittest discover -s cornflow.tests
If you want to only run the unit tests (without a local airflow webserver)::
python -m unittest discover -s cornflow.tests.unit
If you want to only run the integration test with a local airflow webserver::
python -m unittest discover -s cornflow.tests.integration
After if you want to check the coverage report you need to run::
coverage run --source=./cornflow/ -m unittest discover -s=./cornflow/tests/
coverage report -m
or to get the html reports::
coverage html
| null | baobab soluciones | cornflow@baobabsoluciones.es | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Development Status :: 5 - Production/Stable"
] | [] | https://github.com/baobabsoluciones/cornflow | null | >=3.10 | [] | [] | [] | [
"alembic==1.9.2",
"apispec==6.3.0",
"cachetools==5.3.3",
"click==8.1.7",
"cornflow-client==1.3.1rc1",
"cryptography==46.0.5",
"disposable-email-domains==0.0.162",
"Flask==2.3.2",
"flask-apispec==0.11.4",
"Flask-Bcrypt==1.0.1",
"Flask-Compress==1.14",
"flask-cors==4.0.2",
"flask-inflate==0.3",
"Flask-Migrate==4.0.5",
"Flask-RESTful==0.3.10",
"Flask-SQLAlchemy==2.5.1",
"gevent==23.9.1",
"greenlet==2.0.2; python_version < \"3.11\"",
"greenlet==3.0.3; python_version >= \"3.11\"",
"gunicorn==23.0.0",
"jsonpatch==1.33",
"ldap3==2.9.1",
"marshmallow==3.26.2",
"PuLP==2.9.0",
"psycopg2==2.9.9",
"PyJWT==2.8.0",
"pytups==0.86.2",
"requests==2.32.4",
"SQLAlchemy==1.3.21",
"webargs==8.3.0",
"Werkzeug==3.0.6",
"setuptools==78.1.1"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:09:19.841061 | cornflow-1.3.1rc2.tar.gz | 164,137 | 4b/26/fb1b4a961ffae80e5e9dc66f1dc79f734e97d98b765cfb32f88148856b00/cornflow-1.3.1rc2.tar.gz | source | sdist | null | false | 6de207060611ca6cfde0a90013e0b435 | eaa24f081cce675fec4d5f6925f998adb4e801de3f1e3b878418d0e4e33484c1 | 4b26fb1b4a961ffae80e5e9dc66f1dc79f734e97d98b765cfb32f88148856b00 | null | [] | 181 |
2.4 | flaresolverr-cli | 0.3.0 | A requests.Session that proxies through a FlareSolverr instance. | # FlareSolverr Session
[](https://pypi.org/project/flaresolverr-session/)
[](https://github.com/Xavier-Lam/FlareSolverrSession/actions/workflows/ci.yml)
[](https://codecov.io/gh/Xavier-Lam/FlareSolverrSession)
A [`requests.Session`](https://docs.python-requests.org/) that transparently routes all HTTP requests through a [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) instance, allowing you to bypass Cloudflare protection with a familiar Python API.
The package also provides a more powerful [Adapter](#adapter) to handle complex requests if the `Session` is not sufficient.
The project ships with a command-line interface (CLI) for requests and session management, and an RPC client for direct access to the FlareSolverr JSON API.
This project is not responsible for solving challenges itself, it only forwards requests to *FlareSolverr*. If *FlareSolverr* fails to solve a challenge, it will raise an exception. Any issues related to challenge solving should be reported to the *FlareSolverr* project.
## Installation
```bash
pip install flaresolverr-session
```
or
```bash
pip install flaresolverr-cli
```
## Prerequisites
You need a running [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) instance. The quickest way is via Docker:
```bash
docker run -d --name=flaresolverr -p 8191:8191 ghcr.io/flaresolverr/flaresolverr:latest
```
## Usage
### Basic Usage
```python
from flaresolverr_session import Session
with Session("http://localhost:8191/v1") as session:
response = session.get("https://example.com")
print(response.status_code)
print(response.text)
```
It is recommended to set a persistent `session_id`.
```python
session = Session(
"http://localhost:8191/v1",
session_id="my-persistent-session",
)
```
#### Response Object
A `FlareSolverr` metadata object is attached to the `response` as `response.flaresolverr`. It contains details about the request and the challenge solving process returned by *FlareSolverr*.
| Attribute | Description |
|---|---|
| `flaresolverr.status` | `"ok"` on success |
| `flaresolverr.message` | Message from FlareSolverr (e.g. challenge status) |
| `flaresolverr.user_agent` | User-Agent used by FlareSolverr's browser |
| `flaresolverr.start` / `flaresolverr.end` | Request timestamps (ms) |
| `flaresolverr.version` | FlareSolverr server version |
#### Exception Handling
If `FlareSolverr` returns an error response, the session will raise a `FlareSolverrResponseError` exception.
All exceptions defined in the module are based on `FlareSolverrError`, which inherits from `requests.RequestException`. The hierarchy is as follows:
requests.RequestException
└── FlareSolverrError
├── FlareSolverrResponseError
│ └── FlareSolverrChallengeError
└── FlareSolverrUnsupportedMethodError
Exception Details:
| Exception | Description |
|---|---|
| `FlareSolverrResponseError` | FlareSolverr returned an error response. The response dict is available as `response_data` attribute. |
| `FlareSolverrChallengeError` | Challenge solving failed, raised only in `Session`. |
| `FlareSolverrUnsupportedMethodError` | Unsupported HTTP method or content type. |
#### Limitations
- **Only GET and `application/x-www-form-urlencoded` POST** are supported. Otherwise, it will raise `FlareSolverrUnsupportedMethodError`.
- **Headers returned by FlareSolverr may be empty** for some sites, depending on the FlareSolverr version and configuration. An empty HTTP status will be treated as `200`. See [FlareSolverr#1162](https://github.com/FlareSolverr/FlareSolverr/issues/1162).
> If you need more control over the requests or want to use unsupported methods/content types, consider using the [Adapter](#adapter) instead.
### Command-Line Interface
After installation, you can use the `flaresolverr-cli` command. It is a convenient CLI tool to send HTTP requests through FlareSolverr and manage sessions.
It prints the json response from FlareSolverr. If the FlareSolverr URL is not provided via `-f`, it will use the `FLARESOLVERR_URL` environment variable (defaulting to `http://localhost:8191/v1`).
#### Sending requests
The `request` command is the default — you can omit the word `request`:
```bash
flaresolverr-cli https://example.com -o output.html
# GET with a custom FlareSolverr URL
flaresolverr-cli -f http://localhost:8191/v1 https://example.com
# POST with form data (data implies POST)
flaresolverr-cli https://example.com -d "key=value&foo=bar"
```
#### Managing sessions
```bash
# Create a session
flaresolverr-cli -f http://localhost:8191/v1 session create my-session
# Create multiple sessions at once
flaresolverr-cli session create session1 session2 session3
# List all active sessions
flaresolverr-cli session list
# Destroy a session
flaresolverr-cli session destroy my-session
# Clear all sessions
flaresolverr-cli session clear
```
### Adapter
If your requests are more complex than standard `GET` or form `POST`, the module provides an adapter to retrieve Cloudflare challenge solutions from *FlareSolverr* and apply them to your requests without modifying your existing codebase.
```python
import requests
from flaresolverr_session import Adapter
adapter = Adapter("http://localhost:8191/v1")
session = requests.Session()
session.mount("https://nowsecure.nl", adapter)
response = session.get("https://protected-site.com/page")
print(response.text)
```
It is recommended only mount the adapter to specific origins that require Cloudflare bypass. Read the [caveats section](#caveats) before using it.
> Don't use the `Session` provided by `flaresolverr_session` here.
#### Caveats
* The *FlareSolverr* instance and the machine running the adapter **must share the same public IP** (or use the same proxy with a consistent public IP). Otherwise the cookies obtained from *FlareSolverr* will not be accepted by Cloudflare.
* The proxy used for the original request is automatically applied to the *FlareSolverr* request for the reason mentioned above.
* The adapter automatically sends a `GET` request to the original URL to solve the challenge. You can provide a custom `challenge_url` to override this behavior.
* Cloudflare cookies are tied to the `User-Agent` used during challenge solving. The adapter automatically sets the `User-Agent` returned by FlareSolverr.
* The adapter is less reliable than using the [Session](#basic-usage) directly.
#### How It Works
1. The adapter first attempts to send the request normally through its base adapter.
2. If it detects a Cloudflare challenge, the adapter forwards the URL to a FlareSolverr instance.
3. FlareSolverr solves the challenge and returns cookies and a `User-Agent`.
4. The adapter retries the original request using the returned credentials.
### RPC Tool
The `flaresolverr_rpc` module provides a programmatic interface to the FlareSolverr JSON API, ideal for low-level access to raw API responses.
```python
from flaresolverr_session import RPC
with RPC("http://localhost:8191/v1") as rpc:
# Session management
rpc.session.create(session_id="my-session", proxy="http://proxy:8080")
sessions = rpc.session.list()
print(sessions["sessions"])
# HTTP requests
result = rpc.request.get("https://example.com", session_id="my-session")
print(result["solution"]["url"])
print(result["solution"]["response"]) # HTML body
result = rpc.request.post(
"https://example.com",
data="key=value",
session_id="my-session",
)
# Cleanup
rpc.session.destroy("my-session")
```
All methods return the raw JSON response dict from FlareSolverr.
| text/markdown | Xavier-Lam | xavierlam7@hotmail.com | null | null | MIT | null | [
"License :: OSI Approved :: MIT License",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | https://github.com/Xavier-Lam/FlareSolverrSession | null | !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7 | [] | [] | [] | [
"requests",
"pytest; extra == \"dev\"",
"mock; python_version < \"3\" and extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T14:09:17.606770 | flaresolverr_cli-0.3.0.tar.gz | 30,836 | c0/cd/a41078cdecaa2caaddf71fb32b62adf11c3dac0ed6774d51d2e1ebd524e2/flaresolverr_cli-0.3.0.tar.gz | source | sdist | null | false | 0ca18e42115213befea87e9f52a7a0a9 | c31c4bde6698c8967d3861ee995fb106c2f90159de3cb7f191aa6b21e38692f1 | c0cda41078cdecaa2caaddf71fb32b62adf11c3dac0ed6774d51d2e1ebd524e2 | null | [
"LICENSE"
] | 217 |
2.4 | flaresolverr-session | 0.3.0 | A requests.Session that proxies through a FlareSolverr instance. | # FlareSolverr Session
[](https://pypi.org/project/flaresolverr-session/)
[](https://github.com/Xavier-Lam/FlareSolverrSession/actions/workflows/ci.yml)
[](https://codecov.io/gh/Xavier-Lam/FlareSolverrSession)
A [`requests.Session`](https://docs.python-requests.org/) that transparently routes all HTTP requests through a [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) instance, allowing you to bypass Cloudflare protection with a familiar Python API.
The package also provides a more powerful [Adapter](#adapter) to handle complex requests if the `Session` is not sufficient.
The project ships with a command-line interface (CLI) for requests and session management, and an RPC client for direct access to the FlareSolverr JSON API.
This project is not responsible for solving challenges itself, it only forwards requests to *FlareSolverr*. If *FlareSolverr* fails to solve a challenge, it will raise an exception. Any issues related to challenge solving should be reported to the *FlareSolverr* project.
## Installation
```bash
pip install flaresolverr-session
```
or
```bash
pip install flaresolverr-cli
```
## Prerequisites
You need a running [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) instance. The quickest way is via Docker:
```bash
docker run -d --name=flaresolverr -p 8191:8191 ghcr.io/flaresolverr/flaresolverr:latest
```
## Usage
### Basic Usage
```python
from flaresolverr_session import Session
with Session("http://localhost:8191/v1") as session:
response = session.get("https://example.com")
print(response.status_code)
print(response.text)
```
It is recommended to set a persistent `session_id`.
```python
session = Session(
"http://localhost:8191/v1",
session_id="my-persistent-session",
)
```
#### Response Object
A `FlareSolverr` metadata object is attached to the `response` as `response.flaresolverr`. It contains details about the request and the challenge solving process returned by *FlareSolverr*.
| Attribute | Description |
|---|---|
| `flaresolverr.status` | `"ok"` on success |
| `flaresolverr.message` | Message from FlareSolverr (e.g. challenge status) |
| `flaresolverr.user_agent` | User-Agent used by FlareSolverr's browser |
| `flaresolverr.start` / `flaresolverr.end` | Request timestamps (ms) |
| `flaresolverr.version` | FlareSolverr server version |
#### Exception Handling
If `FlareSolverr` returns an error response, the session will raise a `FlareSolverrResponseError` exception.
All exceptions defined in the module are based on `FlareSolverrError`, which inherits from `requests.RequestException`. The hierarchy is as follows:
requests.RequestException
└── FlareSolverrError
├── FlareSolverrResponseError
│ └── FlareSolverrChallengeError
└── FlareSolverrUnsupportedMethodError
Exception Details:
| Exception | Description |
|---|---|
| `FlareSolverrResponseError` | FlareSolverr returned an error response. The response dict is available as `response_data` attribute. |
| `FlareSolverrChallengeError` | Challenge solving failed, raised only in `Session`. |
| `FlareSolverrUnsupportedMethodError` | Unsupported HTTP method or content type. |
#### Limitations
- **Only GET and `application/x-www-form-urlencoded` POST** are supported. Otherwise, it will raise `FlareSolverrUnsupportedMethodError`.
- **Headers returned by FlareSolverr may be empty** for some sites, depending on the FlareSolverr version and configuration. An empty HTTP status will be treated as `200`. See [FlareSolverr#1162](https://github.com/FlareSolverr/FlareSolverr/issues/1162).
> If you need more control over the requests or want to use unsupported methods/content types, consider using the [Adapter](#adapter) instead.
### Command-Line Interface
After installation, you can use the `flaresolverr-cli` command. It is a convenient CLI tool to send HTTP requests through FlareSolverr and manage sessions.
It prints the json response from FlareSolverr. If the FlareSolverr URL is not provided via `-f`, it will use the `FLARESOLVERR_URL` environment variable (defaulting to `http://localhost:8191/v1`).
#### Sending requests
The `request` command is the default — you can omit the word `request`:
```bash
flaresolverr-cli https://example.com -o output.html
# GET with a custom FlareSolverr URL
flaresolverr-cli -f http://localhost:8191/v1 https://example.com
# POST with form data (data implies POST)
flaresolverr-cli https://example.com -d "key=value&foo=bar"
```
#### Managing sessions
```bash
# Create a session
flaresolverr-cli -f http://localhost:8191/v1 session create my-session
# Create multiple sessions at once
flaresolverr-cli session create session1 session2 session3
# List all active sessions
flaresolverr-cli session list
# Destroy a session
flaresolverr-cli session destroy my-session
# Clear all sessions
flaresolverr-cli session clear
```
### Adapter
If your requests are more complex than standard `GET` or form `POST`, the module provides an adapter to retrieve Cloudflare challenge solutions from *FlareSolverr* and apply them to your requests without modifying your existing codebase.
```python
import requests
from flaresolverr_session import Adapter
adapter = Adapter("http://localhost:8191/v1")
session = requests.Session()
session.mount("https://nowsecure.nl", adapter)
response = session.get("https://protected-site.com/page")
print(response.text)
```
It is recommended only mount the adapter to specific origins that require Cloudflare bypass. Read the [caveats section](#caveats) before using it.
> Don't use the `Session` provided by `flaresolverr_session` here.
#### Caveats
* The *FlareSolverr* instance and the machine running the adapter **must share the same public IP** (or use the same proxy with a consistent public IP). Otherwise the cookies obtained from *FlareSolverr* will not be accepted by Cloudflare.
* The proxy used for the original request is automatically applied to the *FlareSolverr* request for the reason mentioned above.
* The adapter automatically sends a `GET` request to the original URL to solve the challenge. You can provide a custom `challenge_url` to override this behavior.
* Cloudflare cookies are tied to the `User-Agent` used during challenge solving. The adapter automatically sets the `User-Agent` returned by FlareSolverr.
* The adapter is less reliable than using the [Session](#basic-usage) directly.
#### How It Works
1. The adapter first attempts to send the request normally through its base adapter.
2. If it detects a Cloudflare challenge, the adapter forwards the URL to a FlareSolverr instance.
3. FlareSolverr solves the challenge and returns cookies and a `User-Agent`.
4. The adapter retries the original request using the returned credentials.
### RPC Tool
The `flaresolverr_rpc` module provides a programmatic interface to the FlareSolverr JSON API, ideal for low-level access to raw API responses.
```python
from flaresolverr_session import RPC
with RPC("http://localhost:8191/v1") as rpc:
# Session management
rpc.session.create(session_id="my-session", proxy="http://proxy:8080")
sessions = rpc.session.list()
print(sessions["sessions"])
# HTTP requests
result = rpc.request.get("https://example.com", session_id="my-session")
print(result["solution"]["url"])
print(result["solution"]["response"]) # HTML body
result = rpc.request.post(
"https://example.com",
data="key=value",
session_id="my-session",
)
# Cleanup
rpc.session.destroy("my-session")
```
All methods return the raw JSON response dict from FlareSolverr.
| text/markdown | Xavier-Lam | xavierlam7@hotmail.com | null | null | MIT | null | [
"License :: OSI Approved :: MIT License",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | https://github.com/Xavier-Lam/FlareSolverrSession | null | !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7 | [] | [] | [] | [
"requests",
"pytest; extra == \"dev\"",
"mock; python_version < \"3\" and extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T14:09:15.259434 | flaresolverr_session-0.3.0.tar.gz | 33,594 | 9e/37/d0d6fe2c481e42fc045cf47a6196d01a2061a42f4b3321c29b02f2e3b9ae/flaresolverr_session-0.3.0.tar.gz | source | sdist | null | false | 3dbe93580db189d27c47dc4e2dab6752 | 39a9becab86a68090b9b0fa8cff9b397d328fb4183f5501f1f61e8c4a78de854 | 9e37d0d6fe2c481e42fc045cf47a6196d01a2061a42f4b3321c29b02f2e3b9ae | null | [
"LICENSE"
] | 217 |
2.4 | btc-embedded | 25.3.3b1 | API wrapper for BTC EmbeddedPlatform REST API | # BTC EmbeddedPlatform REST API Package for Python
The BTC REST API wrapper for Python is designed to facilitate the automation of test workflows using the BTC EmbeddedPlatform REST API
- handle startup of the headless BTC EmbeddedPlatform application on windows and linux (docker)
- separation of concerns: configuration ←→ workflow steps
- error handling (showing relevant messages on error, etc.)
- uniform responses: api wrapper calls such as "ep.get(...)", "ep.post(...)", etc.) will always return one of the following: an object, a list of objects or nothing
## Getting Started
The python module btc_embedded lets you start & stop a headless BTC EmbeddedPlatform and allows you to define your test workflows for automation and CI purposes.
- Installing the module works like for any other python module: pip install btc_embedded (You can always use the latest version of this module, as it's designed to remain compatible with older versions of BTC EmbeddedPlatform)
- Importing it in your Python script: **from btc_embedded import EPRestApi**
- Creating the API object: **ep = EPRestApi()**
When creating the API object without further parameters, the module looks for an instance of BTC EmbeddedPlatform on http://localhost:1337. If it doesn't find a running instance, it will start one and return once it connected to it. The console output will look roughly like this:
```Applying global config from 'C:\ProgramData\BTC\ep\btc_config.yml'
Waiting for BTC EmbeddedPlatform 24.2p0 to be available:
Connecting to BTC EmbeddedPlatform REST API at http://localhost:1337
....
BTC EmbeddedPlatform has started.
Applied preferences from the config
```
Once the console indicates that "BTC EmbeddedPlatform has started", you can access the api documentation by opening http://localhost:1337 in your browser. If you'd like to check the docs without running BTC EmbeddedPlatform, you can use the static PDF docs that are part of the public btc-ci-workflow GitHub repository.
## Configuration
You'd like to use a specific BTC version or specify preferences such as the Matlab version to be used, settings for vector generation, etc.? Although you can do this directly in your script, we recommend to keep this sort of configuration separate from the actual test workflow. For this purpose you can use a YAML-based configuration file (btc_config.yml):
Windows
- If the environment variable **BTC_API_CONFIG_FILE** is set and points to a config file, it is being considered and any preferences defined inside are applied automatically when the API object is created
- Otherwise, the API wrapper will add a config file “C:/ProgramData/BTC/ep/config.yml” with some reasonable defaults (e.g., the EP install directory, the latest compatible Matlab version, etc.)
- Examples of the config file can be found here:
- https://github.com/btc-embedded/btc_embedded/blob/main/btc_embedded/resources/btc_config_windows.yml
- https://github.com/btc-embedded/btc-ci-workflow/blob/main/btc_config.yml
- Some report templates are also added and can be used when creating a project report
## Tolerances
Tolerances for requirements-based testing (RBT) and back-to-back testing (B2B) can be specified as part of the btc_config.yml file for BTC EmbeddedPlatform versions 24.1 and higher (see comments in [btc_config.yml](https://github.com/btc-embedded/btc_embedded/blob/main/btc_embedded/resources/btc_config_windows.yml) for more details).
When configured in the config, they will automatically be applied to the test project(supported with EP 24.1 and beyond).
For each scope, for each DISP/OUT the signal is checked:
1. Does the signal name match any of the "signal-name-based" tolerance definitions?
- first matching tolerance definition is applied (based on regex <-> signal-name)
- If no signal-name based tolerance was defined, default tolerances based on data type are considered:
2. Does the signal use a floating point data type? [ 'double', 'single', 'float', 'float32', 'float64', 'real' ]
- apply default tolerances for floats (if defined)
3. Does the signal use a fixed-point data type? (integer with LSB < 1)
- apply default tolerances for fixed-point (if defined)
- tolerance can also be defined as a multiple of the LSB (e.g. 1*LSB)
**abs**: absolute tolerance - a deviation <= **abs** will be accepted as PASSED
**rel**: relative tolerance - accepted deviation <= (reference value * **rel**) will be accepted as PASSED
useful for floats to compensate for low precision on high float values
```yaml
tolerances:
B2B:
# specific tolerances for matching signals
signal-name-based:
- regex: .*_write.*
rel: 2e-1
- regex: .*dsout_.*
abs: 4e-6
rel: 4e-4
# default tolerances for anything else
floating-point:
abs: 0.001
rel: 0.01
fixed-point:
abs: 1*LSB
```
## Docker/Linux
- the config & the env variable are part of the build
- the report-templates should also be part of the image
- the tests for the btc_embedded module also run on Docker, check out the repo if you're interested: https://github.com/btc-embedded/btc_embedded/blob/main/test/Dockerfile
## Licensing & Prerequisites (on Windows)
- BTC EmbeddedPlatform must be installed incl. the REST Server Addon
- The Matlab versions you intend to use must be integrated with BTC EmbeddedPlatform (can be selected during installation)
- A license server must be configured a value such as 27000@myserver.myorg in one of the following ways:
- As the value of the property licenseLocation in the global or project-specific btc_config.yml
- As the value of the constructor argument license_location when creating the EPRestApi() object in Python
- As the value of the registry key called OSCCSD_LICENSE_FILE in "HKEY_CURRENT_USER/SOFTWARE/FLEXlm License Manager" (automatically set when using the license dialog of the GUI)
## Reporting
### Project Report & Templates
- When creating the project report the user can add the name of a report template by appending '?template-name=rbt-ec' to the API call
- This expects a report template xml file to be present in the report templates directory which is indicated by the preference REPORT_TEMPLATE_FOLDER (part of the btc_config.yml)
- If the user didn’t configure it differently, some default templates are automatically placed into “C:/ProgramData/BTC/ep/report-templates”
- rbt-b2b-ec.xml
- rbt-b2b-tl.xml
- rbt-ec.xml
- rbt-sil-only.xml
- rbt-tl.xml
- b2b-only-ec.xml
- b2b-only-tl.xml
- regression-test-ec.xml
- regression-test-sil-only.xml
- regression-test-tl.xml
- Users can create report templates according to their own needs via the GUI, save them in the report template folder and refer to them by name when creating a project report.
## BTC Summary Report
- When testing multiple projects in batch it’s helpful to have a summary report that lists all project, their overall status and allows to drill down into the respective project reports.
- Two things are needed to achieve this:
1. For each individual project (e.g., a workflow that works on one model/epp), a result object must be created (see https://github.com/btc-embedded/btc-ci-workflow/blob/main/examples/btc_test_workflow.py#L58).
2. The result objects for each project needs to be added to a list and this list will then be passed used for creating the report (see https://github.com/btc-embedded/btc-ci-workflow/blob/main/examples/test_multiple_projects.py)
## Logging
This module uses a logger named 'btc_embedded' which you can access by its name.
### Configure custom logging
```python
import logging
# Access btc_embedded logger
logger = logging.getLogger('btc_embedded')
# Collect logging output in a file
log_file = os.path.join(os.path.dirname(__file__), 'btc_embedded.log')
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(logging.Formatter('[%(asctime)s] [%(levelname)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler(file_handler)
```
### Configure log level
Chosing a log level lower than the one configured for the logger will have no effect. By default, the module will log using the INFO level. You can adapt this when creating the API object:
```python
# Create BTC API object with a customized log level
ep = EPRestApi(log_level=logging.DEBUG)
```
### Disable logging
If you wish to disable logging entirely, simply set the log level to LOGGING_DISABLED:
```python
from btc_embedded import EPRestApi, LOGGING_DISABLED
# disable logging
ep = EPRestApi(log_level=LOGGING_DISABLED)
```
| text/markdown | null | Thabo Krick <thabo.krick@btc-embedded.com>, Nathan Drasovean <nathan.drasovean@btc-embedded.com>, Ferdinand Becker <ferdinand.becker@btc-embedded.com> | null | null | null | null | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Topic :: Software Development :: Testing",
"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"
] | [] | null | null | null | [] | [] | [] | [
"requests",
"pyyaml"
] | [] | [] | [] | [
"Homepage, https://github.com/btc-embedded/btc_embedded"
] | twine/6.2.0 CPython/3.11.0 | 2026-02-20T14:09:01.571699 | btc_embedded-25.3.3b1.tar.gz | 3,537,650 | 44/46/3fd7ff7bc8386dca0d04231541de0ced8dff03dc413fbd125ada0daf5b87/btc_embedded-25.3.3b1.tar.gz | source | sdist | null | false | 03c593246c19a6c2ca19cf343cc6b03e | 9902674a401fe113e1e36a8637f74fc230d0a438c5c07134d4c12e187c394946 | 44463fd7ff7bc8386dca0d04231541de0ced8dff03dc413fbd125ada0daf5b87 | MIT | [
"LICENSE.txt"
] | 179 |
2.4 | dropdrop | 2.0.1 | Automated pipeline for detecting droplets and inclusions in microscopy images, powered by Cellpose | # DropDrop
Automated pipeline for detecting droplets and inclusions (beads) in microscopy z-stacks using Cellpose segmentation and morphological analysis.
Tailored for the EVOS M5000 Imaging System.
## Installation
```bash
# Using uv (recommended)
uv pip install dropdrop
# Using pip
pip install dropdrop
```
### GPU support (CUDA)
On Linux/Windows with an NVIDIA GPU, install CUDA-enabled PyTorch **before** installing DropDrop:
```bash
# Install PyTorch with CUDA 12.6 (adjust version for your driver)
uv pip install torch torchvision --index-url https://download.pytorch.org/whl/cu126
# Then install DropDrop
uv pip install dropdrop
```
On macOS, GPU acceleration via Metal (MPS) is included in the default PyTorch build — no extra steps needed.
### From source
```bash
git clone https://github.com/yourusername/dropdrop.git
cd dropdrop
uv pip install -e .
```
## Quick Start
```bash
# Single directory — interactive prompts for settings
dropdrop ./images
# Process only first 5 frames (for testing)
dropdrop ./images -n 5
# With interactive editor
dropdrop ./images -e
# Multiplex mode — batch process subdirectories
dropdrop -m ./samples
```
## Usage
### Single Mode
```bash
# Basic run (prompts for settings interactively)
dropdrop ./images
# Custom output directory
dropdrop ./images ./results/my_project
# With editor and archive
dropdrop ./images -e -z
```
### Multiplex Mode
Process multiple sample directories at once. Each subdirectory is labeled interactively and processed as a separate sample, then combined into a multiplexed report.
```bash
dropdrop -m ./samples_parent_dir
dropdrop -m ./samples_parent_dir -z # Archive result
```
### Resume (Resurrect)
If a multiplex run is interrupted, resume from where it left off:
```bash
dropdrop -r
```
### Cache Control
```bash
dropdrop ./images --no-cache # Disable caching
dropdrop ./images --clear-cache # Clear cache before run
```
## Interactive Editor
The editor (`-e`) allows manual correction of detected inclusions:
| Key | Action |
|-----|--------|
| Left-click | Add inclusion |
| Right-click (hold) | Remove inclusions |
| `s` | Toggle droplet selection (hover over droplet) |
| `u` | Undo last action |
| `c` | Clear all inclusions in frame |
| `d` | Toggle droplet visibility |
| Arrow keys / Space | Navigate frames |
| `q` / Esc | Exit |
Disabled droplets (gray with X) are excluded from the final results.
## Output Structure
### Single mode
```
results/<YYYYMMDD>_<label>/
data.csv # Raw detection data
summary.txt # Settings and statistics
report.png # Combined report with sample frames
size_distribution.png # Droplet diameter histogram
poisson_comparison.png # Bead distribution vs theoretical
```
### Multiplex mode
```
results/<YYYYMMDD>_multiplex/
data.csv # Merged data with sample column
summary.txt # Per-sample statistics
summary_report.png # Comparison table, overlaid plots, sample collage
size_distribution.png # Overlaid diameter histograms
poisson_comparison.png # Overlaid inclusion distributions
```
### data.csv columns
| Column | Description |
|--------|-------------|
| `sample` | Sample label (multiplex only) |
| `frame` | Frame index |
| `droplet_id` | Droplet ID within frame |
| `center_x`, `center_y` | Droplet center coordinates (px) |
| `diameter_px`, `diameter_um` | Droplet diameter |
| `area_px`, `area_um2` | Droplet area |
| `inclusions` | Number of inclusions detected |
## Architecture
```
CLI
-> Detection (per sample) -> .tmp_<label>/data.csv + sample_*.png
-> Analysis.run(output_dir) -- auto-discovers .tmp_* dirs
1 sample -> single report
2+ samples -> multiplex report
-> Cleanup .tmp_* dirs
-> Archive (optional)
```
## Configuration
Create `config.json` in your working directory to customize detection parameters:
```json
{
"cellpose_flow_threshold": 0.4,
"cellpose_cellprob_threshold": 0.0,
"erosion_pixels": 5,
"kernel_size": 7,
"tophat_threshold": 30,
"min_inclusion_area": 7,
"max_inclusion_area": 50,
"edge_buffer": 5,
"min_droplet_diameter": 80,
"max_droplet_diameter": 200,
"px_to_um": 1.14,
"cache": {
"enabled": true,
"max_frames": 100
}
}
```
### Parameters
| Parameter | Description |
|-----------|-------------|
| `cellpose_flow_threshold` | Cellpose flow threshold for segmentation |
| `cellpose_cellprob_threshold` | Cellpose cell probability threshold |
| `erosion_pixels` | Pixels to erode droplet mask before inclusion detection |
| `kernel_size` | Morphological kernel size for black-hat transform |
| `tophat_threshold` | Threshold for inclusion detection |
| `min/max_inclusion_area` | Inclusion size constraints (px) |
| `edge_buffer` | Buffer from image edge to ignore inclusions |
| `min/max_droplet_diameter` | Droplet size constraints (px) |
| `px_to_um` | Pixel to micrometer conversion factor |
## Requirements
- Python 3.12+
- CUDA-capable GPU (recommended for Cellpose)
## License
MIT
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"cellpose>=4.0.7",
"matplotlib>=3.10.6",
"numpy>=2.3.3",
"opencv-python>=4.11.0.86",
"pandas>=2.3.3",
"scipy>=1.16.2",
"seaborn>=0.13.2",
"tqdm>=4.67.1",
"pytest>=8.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:08:53.599265 | dropdrop-2.0.1.tar.gz | 88,410 | 90/05/393dbff67b6a23a9e33e7f6827d4264e86ea9a65123a20430a980951bff0/dropdrop-2.0.1.tar.gz | source | sdist | null | false | c0a4e8fd733b8f3f33be5b8d8ce80a26 | 01524ea1e7e60fee788f6ff7699ff1252a6373bba34dcf2c0f146c93c554cebc | 9005393dbff67b6a23a9e33e7f6827d4264e86ea9a65123a20430a980951bff0 | MIT | [
"LICENSE"
] | 207 |
2.4 | flip-utils | 0.1.0 | FLIP - Federated Learning for Imaging Platform library built on NVIDIA FLARE | <!--
Copyright (c) 2026 Guy's and St Thomas' NHS Foundation Trust & King's College London
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
# flip-fl-base
This repository contains the FLIP federated learning base application built on NVIDIA FLARE (NVFLARE). It includes the FL services (server, clients, admin API) and the base application code that users extend with their own training logic.
## Quick Start
### Prerequisites
- Docker and Docker Compose
- [uv](https://github.com/astral-sh/uv) (Python package manager)
- AWS CLI configured (for downloading test data)
### 1. Provision an FL Network
Before running anything, you need to provision a federated learning network. This generates the required certificates, keys, and configuration files:
```bash
make nvflare-provision NET_NUMBER=1
```
This creates:
- Network-specific compose file: `deploy/compose-net-1.yml`
- Service secrets in `workspace/net-1/services/` (gitignored)
You can provision multiple networks with different ports:
```bash
make nvflare-provision NET_NUMBER=2 FL_PORT=8004 ADMIN_PORT=8005
```
**Warning**: Provisioned files contain cryptographic signatures. Any modification will cause errors. Always re-run provisioning if changes are needed.
### 2. Build Docker Images
```bash
make build NET_NUMBER=1
```
### 3. Start the FL Network
```bash
make up NET_NUMBER=1
```
This starts:
- `fl-server-net-1`: Aggregation server
- `fl-client-1-net-1`, `fl-client-2-net-1`: Training clients
- `flip-fl-api-net-1`: FastAPI admin interface
To stop the network:
```bash
make down NET_NUMBER=1
```
To clean up images and containers:
```bash
make clean NET_NUMBER=1
```
## Development Mode
DEV mode lets you test your FL applications locally before deploying to production.
### Configure Environment
Edit `.env.development`:
```bash
LOCAL_DEV=true
DEV_IMAGES_DIR=../data/accession-resources # Path to your images
DEV_DATAFRAME=../data/sample_get_dataframe.csv # Path to your dataframe
JOB_TYPE=standard
```
### Add Your Application Files
Place your files in `src/<JOB_TYPE>/app/custom/`:
- `trainer.py` - Training logic (FLIP_TRAINER executor)
- `validator.py` - Validation logic (FLIP_VALIDATOR executor)
- `models.py` - Model definitions (`get_model` function)
- `config.json` - Hyperparameters (requires `LOCAL_ROUNDS` and `LEARNING_RATE`)
- `transforms.py` - Data transforms (optional)
### Run the Simulator
```bash
make run-container
```
This runs the NVFLARE simulator in Docker with 2 clients, mounting your app folder for live changes.
## Testing
### Download Test Data
Download x-ray classification test data (requires AWS S3 access):
```bash
make download-xrays-data
```
Download spleen segmentation test data (requires AWS S3 access):
```bash
make download-spleen-data
```
Download model checkpoints for evaluation tests:
```bash
make download-checkpoints
```
### Run Integration Tests
Test different job types with the spleen dataset:
```bash
# Standard federated training (classification task)
make test-xrays-standard
# Standard federated training (segmentation task)
make test-spleen-standard
# Model evaluation pipeline (requires model checkpoint file)
make test-spleen-evaluation
# Diffusion model training
make test-spleen-diffusion
# Run all integration tests
make test
```
### Run Unit Tests
```bash
make unit-test
```
### Manage Test Applications
Copy the spleen test app to your dev folder:
```bash
make copy-spleen-app
```
Save your changes back to the test folder:
```bash
make save-spleen-app
```
## Project Structure
```text
├── src/ # FL application types
│ ├── standard/ # Standard FedAvg training
│ ├── evaluation/ # Distributed model evaluation
│ ├── diffusion_model/ # Two-stage VAE + diffusion training
│ └── fed_opt/ # Custom federated optimization
├── fl_services/ # NVFLARE service definitions
│ ├── fl-base/ # Base Docker image
│ ├── fl-api-base/ # FastAPI admin service
│ ├── fl-client/ # Base FL client service
│ └── fl-server/ # Base FL server service
├── deploy/ # Docker compose files and templates
├── workspace/ # Provisioned secrets (gitignored)
├── tests/ # Integration test applications
| ├── examples/ # Example applications for integration testing
| └── unit/ # Unit tests
└── .env.development # Local environment configuration
```
## Job Types
Set via `JOB_TYPE` environment variable:
| Type | Description |
| ------ | ------------- |
| `standard` | Federated training with FedAvg aggregation (default) |
| `evaluation` | Distributed model evaluation without training |
| `diffusion_model` | Two-stage training (VAE encoder + diffusion) |
| `fed_opt` | Custom federated optimization |
## NVFLARE App Structure
An NVFLARE app requires this structure:
```text
app/
├── config/
│ ├── config_fed_server.json
│ └── config_fed_client.json
└── custom/
├── trainer.py
├── validator.py
├── models.py
└── config.json
```
For different configurations per client/server, use multiple app folders with a `meta.json` containing a `deploy_map`. See [NVFLARE documentation](https://nvflare.readthedocs.io/en/2.6/real_world_fl/job.html).
## Application and tutorials
Applications that will run on FLIP will take files from the `app` of choice (contained in both the `custom` and `config` folders described above), and files that are uploaded by the user to the UI. These files are customisable by the user, and examples compatible with different types of apps will be available in `tutorials`.
These are the following app / tutorial compatibilities:
| App | Tutorial |
|-----|----------|
|`standard`|`image_segmentation/3d_spleen_segmentation`|
|`diffusion_model`|`image_synthesis/latent_diffusion_model`|
|`fed_opt`|`image_segmentation/3d_spleen_segmentation`|
|`evaluation`|`image_evaluation/3d_spleen_segmentation`|
|`standard`|`image_classification/xray_classification`|
## User Application Requirements
The standard application requires:
| File | Description |
|------|-------------|
| `trainer.py` | Training logic with `FLIP_TRAINER` class inheriting from Executor |
| `validator.py` | Validation logic with `FLIP_VALIDATOR` class inheriting from Executor |
| `models.py` | Model definitions with `get_model()` function |
| `config.json` | Must include `LOCAL_ROUNDS` and `LEARNING_RATE` |
## Production Testing via GitHub Actions
Pull requests automatically push to a dev S3 bucket for testing:
```text
s3://flipdev/base-application-dev/pull-requests/<PR_NUMBER>/src/
```
To test on the FLIP platform, update `FL_APP_BASE_BUCKET` in the [flip repo environment variables](https://github.com/londonaicentre/FLIP/blob/main/.env.development) to point to your PR's bucket.
## S3 Bucket Mounting (Optional)
For automatic sync between local development and S3:
1. Install [s3fs](https://github.com/s3fs-fuse/s3fs-fuse)
2. Configure credentials:
```bash
echo ACCESS_KEY_ID:SECRET_ACCESS_KEY > ~/.passwd-s3fs
chmod 600 ~/.passwd-s3fs
```
3. Mount the bucket:
```bash
s3fs flip:/base-application-dev/src/standard/app/ ./app/ -o passwd_file=${HOME}/.passwd-s3fs
```
For automatic mounting on boot, add to `/etc/fstab`:
```bash
flip <PATH_TO_APP>/app fuse.s3fs _netdev,allow_other 0 0
```
Test with `mount -a` before relying on it.
## CI/CD
These workflows use GitHub OIDC to securely authenticate to AWS (no long-lived AWS keys required). They use an IAM role with a policy that allows S3 operations.
- **PR to any branch**: Pushes to dev S3 bucket for testing on AWS dev account:
- (dev) `s3://flipdev/base-application-dev/pull-requests/<PR_NUMBER>/src/`
- **Merge to develop**: Syncs `src/` to S3 buckets on AWS dev and staging accounts:
- (dev) `s3://flipdev/base-application-dev/src/`
- (staging) `s3://flipstag/base-application/src/`
- **Merge to main**: Syncs `src/` to S3 bucket in AWS prod account:
- (prod) `s3://flipprod/base-application/src/`
> **Warning**: Never manually sync to the production bucket.
## Makefile Reference
### Network Management
| Command | Description |
| --------- | ------------- |
| `make nvflare-provision NET_NUMBER=X` | Provision FL network X |
| `make build NET_NUMBER=X` | Build Docker images for network X |
| `make up NET_NUMBER=X` | Start FL network X |
| `make down NET_NUMBER=X` | Stop FL network X |
| `make clean NET_NUMBER=X` | Remove containers and images |
### Development
| Command | Description |
| --------- | ------------- |
| `make run-container` | Run NVFLARE simulator in Docker |
### Testing Commands
| Command | Description |
| --------- | ------------- |
| `make unit-test` | Run pytest unit tests |
| `make test-spleen-standard` | Test standard job with spleen data |
| `make test-spleen-evaluation` | Test evaluation job with spleen data |
| `make test-spleen-diffusion` | Test diffusion model with spleen data |
| `make test` | Run all integration tests |
### Data Management
| Command | Description |
| --------- | ------------- |
| `make download-spleen-data` | Download spleen test images from S3 |
| `make download-checkpoints` | Download model checkpoints from S3 |
| `make copy-spleen-app` | Copy test app to dev folder |
| `make save-spleen-app` | Save dev changes to test folder |
| `make pull-spleen-app` | Pull latest app from tutorials repo |
| text/markdown | AI Centre for Value Based Healthcare, Guy's and St Thomas' NHS Foundation Trust, King's College London | "A. Triay Bagur" <alexandre.triay_bagur@kcl.ac.uk>, "P. Wright" <p.wright@kcl.ac.uk>, "R. Garcia-Dias" <r.gaciadias@gmail.com>, "V. Fernandez" <virginia.fernandez@kcl.ac.uk> | null | "A. Triay Bagur" <alexandre.triay_bagur@kcl.ac.uk>, "P. Wright" <p.wright@kcl.ac.uk>, "R. Garcia-Dias" <r.gaciadias@gmail.com>, "V. Fernandez" <virginia.fernandez@kcl.ac.uk> | null | federated-learning, flip, medical-imaging, nvflare | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Healthcare Industry",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Scientific/Engineering :: Medical Science Apps."
] | [] | null | null | >=3.12 | [] | [] | [] | [
"nvflare==2.7.1",
"pandas>=2.3.0",
"pydantic-settings>=2.10.1",
"pydantic>=2.11.7",
"requests>=2.31.0",
"boto3>=1.38.31; extra == \"full\"",
"einops==0.8.1; extra == \"full\"",
"gdown==5.2.0; extra == \"full\"",
"lpips==0.1.4; extra == \"full\"",
"monai>=1.5.1; extra == \"full\"",
"nibabel>=5.3.2; extra == \"full\"",
"pydicom>=3.0.1; extra == \"full\""
] | [] | [] | [] | [
"Homepage, https://github.com/londonaicentre/flip-fl-base",
"Repository, https://github.com/londonaicentre/flip-fl-base",
"Documentation, https://github.com/londonaicentre/flip-fl-base#readme",
"Issues, https://github.com/londonaicentre/flip-fl-base/issues"
] | uv/0.10.4 {"installer":{"name":"uv","version":"0.10.4","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-20T14:08:37.832480 | flip_utils-0.1.0.tar.gz | 44,076 | 6c/a4/88a99a9dd0ef92c01664e79a8db090bbc04389147aa1ad35f92c6888ce25/flip_utils-0.1.0.tar.gz | source | sdist | null | false | bb005631876327ed7a72741f21a4079d | 5bb6b07410da7f9b18bf56f36d7680714963308e0bd691511425b5a7274190ac | 6ca488a99a9dd0ef92c01664e79a8db090bbc04389147aa1ad35f92c6888ce25 | Apache-2.0 | [
"LICENSE.md",
"NOTICE.md"
] | 223 |
2.4 | lupin-grognard | 2.4.0 | Lupin linter tool | # Grognard
Lupin linter tool
| null | null | null | null | null | null | cli, linter | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Information Technology",
"Topic :: Software Development :: Quality Assurance",
"Programming Language :: Python :: 3.10",
"License :: OSI Approved :: MIT License"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"typer[all]>=0.6.1",
"emoji==2.2.0",
"Jinja2>=3.1.2",
"cmakelang==0.6.13",
"PyYAML==6.0.1",
"pytest==7.1.3; extra == \"test\"",
"flake8==5.0.4; extra == \"test\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T14:08:08.478674 | lupin_grognard-2.4.0.tar.gz | 31,225 | a0/61/982ed8615e9d1b5ed7b760c6cc4df8c826ef5af09b8fbc91b0254c0cd47e/lupin_grognard-2.4.0.tar.gz | source | sdist | null | false | d66a351bc8bd5963d424e43b98e674f6 | a3fd9f7a1c6cc1a4db34f04ad958ea3aa0e036c3b3fcfa302bedb96e710eb9bd | a061982ed8615e9d1b5ed7b760c6cc4df8c826ef5af09b8fbc91b0254c0cd47e | null | [] | 214 |
2.4 | vd-dlt-salesforce | 0.1.1 | Salesforce connector for vd-dlt pipelines | # vd-dlt-salesforce
Salesforce connector for vd-dlt pipelines with automatic incremental loading.
## Installation
```bash
pip install vd-dlt-salesforce
```
## Features
- 15 standard Salesforce objects
- Incremental loading with SystemModstamp
- Full SOQL query support
- Automatic pagination
## Usage
See full documentation at https://github.com/accelerate-data/vd-dlt-connectors
| text/markdown | null | VibeData <info@vibedata.dev> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Topic :: Database"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"dlt",
"simple-salesforce>=1.12.0",
"vd-dlt>=0.1.0"
] | [] | [] | [] | [
"Homepage, https://github.com/accelerate-data/vd-dlt-connectors",
"Repository, https://github.com/accelerate-data/vd-dlt-connectors"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:07:52.847521 | vd_dlt_salesforce-0.1.1.tar.gz | 3,965 | 01/6d/b0d3699cd0ad3185f183fc4adf1c151c9b9831dd50065c1e11f6932bea67/vd_dlt_salesforce-0.1.1.tar.gz | source | sdist | null | false | 8c2b3ca9d063ae7bba3014660bbcf32e | 6995dc4d17c5bbac1871922204f9d2db69dcb465322fcb49ab8e9462c41d3275 | 016db0d3699cd0ad3185f183fc4adf1c151c9b9831dd50065c1e11f6932bea67 | MIT | [] | 220 |
2.4 | nexus-quant | 2.0.1 | The world's most elegant, institutional-grade quantitative risk API. | <p align="center">
<img src="https://raw.githubusercontent.com/nexus-quant/nexus/main/docs/assets/nexus_logo.png" alt="Nexus Risk Engine" height="150">
</p>
# Nexus: The Enterprise Quantitative Risk Framework
Welcome to **Nexus**. Nexus is an institutional-grade library implementing 40+ advanced risk measurements, including classical metrics, downside asymmetry, tail exceedance, and convex entropic bounds (EVaR, EDaR, RLDaR).
Inspired by `scikit-learn` and Google's core architectures, Nexus seamlessly abstracts disjointed mathematical scripts into a devastatingly powerful execution manifold: the **`NexusAnalyzer`**. Whether you are an indie quant building alpha models who has identified undervalued opportunities, or a Wall Street hedge fund requiring millisecond precision optimizations via MOSEK/CVXPY, Nexus provides the native mathematical infrastructure needed to evaluate and construct risk-efficient portfolios.
| | **[Documentation](https://nexus-the-enterprise-quantitative-risk-framework.readthedocs.io/en/latest/) · [Tutorials](#) · [Release Notes](#)** |
|:--------------|:-------------------------------------------------------------|
| **Open Source**| [](#) [](#) |
| **Tutorials** | [](#) |
| **Community** | [](#) [](#) |
| **CI/CD** | [](#) [](https://nexus-the-enterprise-quantitative-risk-framework.readthedocs.io/en/latest/) |
| **Code** | [](https://pypi.org/project/nexus-quant/) [](#) [](#) |
| **Downloads** | [](#) [](#) [-1.2k-blue)](#) |
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/risk_manifold.png" alt="Nexus Risk Manifold" width="800">
</p>
---
## Table of contents
- [📚 Official Documentation](#-official-documentation)
- [Why Nexus?](#why-nexus)
- [Getting started](#getting-started)
- [Features & Mathematical Supremacy](#features--mathematical-supremacy)
- [Return Regimes & Asset Efficiency](#return-regimes--asset-efficiency)
- [Multivariate Dynamics & Temporal Regimes](#multivariate-dynamics--temporal-regimes)
- [Dispersion & Volatility](#dispersion--volatility)
- [Downside Asymmetry](#downside-asymmetry)
- [Tail Exceedance](#tail-exceedance)
- [Convex Entropic Bounds](#convex-entropic-bounds)
- [Unparalleled Solver Routing](#unparalleled-solver-routing)
- [Project Principles](#project-principles-and-design-decisions)
- [Installation](#-installation)
- [Testing & Developer Setup](#testing--developer-setup)
- [License & Disclaimer](#license)
---
## 📚 Official Documentation
Nexus is built with the rigor and scale of Tier-1 technology groups (such as DeepMind or Google Research), cleanly abstracting extreme mathematical theories into a functional programmatic mesh.
For an exhaustive and mathematically rigorous breakdown of our architectural patterns, Entropic bounds, solver routing algorithms, and a complete API reference, please consult the official ReadTheDocs portal:
**[📖 Read the Full Documentation on ReadTheDocs ➔](https://nexus-the-enterprise-quantitative-risk-framework.readthedocs.io/en/latest/)**
The documentation deeply covers:
- **Core Architecture & The Analyzer Facade**
- **Dynamic Solver Fallbacks (MOSEK/CVXPY Integration)**
- **Entropic Mathematics & Chernoff Boundaries**
- **Comprehensive Data Handling Pipelines**
---
## Why Nexus?
**Nexus** was explicitly engineered for absolute scale and mathematical extremity.
1. **Convex Entropic Supremacy**: Standard libraries rely on empirical Historical VaR or CVaR. Nexus natively implements **Entropic Value at Risk (EVaR)** and **Relativistic VaR (RLVaR)**, bounding tail risks using strict Chernoff inequalities that are completely invisible to standard historical sampling.
2. **Path-Dependent Drawdown Cones**: Nexus introduces **Entropic Drawdown at Risk (EDaR)**, a revolutionary metric mapping underwater geometric capital erosion onto exponential mathematically-bound cones, rather than just simple peak-to-trough calculations.
3. **Dynamic Solver Fallbacks**: Nexus detects institutional optimization licenses (MOSEK/GUROBI) and perfectly routes extreme thermodynamics through them via `cvxpy`. If licenses are missing, it flawlessly falls back to high-grade `scipy` optimizers without crashing your analytical pipeline.
---
## Getting started
Gone are the days of importing disjointed functions. Nexus abstracts the entire mathematical realm into a single `NexusAnalyzer` object. Here is an example demonstrating how easy it is to fetch real-life stock data and construct an exhaustive mathematical risk report matrix natively.
```python
import numpy as np
from nexus.data.loader import NexusDataLoader
from nexus.analytics.analyzer import NexusAnalyzer
# 1. Effortless Market Ingestion
loader = NexusDataLoader()
asset_names, historical_returns = loader.fetch(
['AAPL', 'MSFT', 'JPM'],
start_date='2020-01-01'
)
# Build an equal-weighted portfolio combination
weights = np.ones(len(asset_names)) / len(asset_names)
portfolio_returns = np.sum(historical_returns * weights, axis=1)
# 2. Institutional Calibration
analyzer = NexusAnalyzer()
analyzer.calibrate(portfolio_returns)
# 3. Exhaustive Mathematical Execution
report_df = analyzer.compute(alpha=0.05, annualization_factor=252)
# Specific Dictionary Retrieval
cvar = analyzer.fetch('Cond VaR (0.05)')
print(report_df)
```
### The Output
```text
Asset_0
Volatility (Ann) 0.230763
Mean Abs Dev (MAD) 2.388695
Gini Mean Diff 3.579301
Lower Part Moment (LPM1) 1.096828
Value at Risk (0.05) 0.019100
Cond VaR (0.05) 0.033262
Entropic VaR (0.05) 0.067949
Cond DaR (0.05) -0.232770
Entropic DaR (0.05) 0.259398
Max Drawdown (MDD) -0.344122
Ulcer Index 0.091181
Calmar Ratio 0.884100
...
```
---
## Features & Mathematical Supremacy
In this section, we detail Nexus' primary architectural pillars. More exhaustive equations can be found in our core modules.
### Return Regimes & Asset Efficiency
Institutional portfolio management relies on hierarchical clustering of temporal returns and risk-adjusted efficiency plotting.
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/monthly_heatmap.png" alt="Monthly Return Heatmap" width="800">
</p>
- **Chronological Return Clustering**: QuantStats-style Y/M grids isolating momentum drifts, tax-loss harvesting impacts, and macro-regime seasonality across annual structures.
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/risk_return_scatter.png" alt="Risk vs Return Efficiency" width="800">
</p>
- **Asset Efficiency Hierarchies**: Volatility vs. Return distributions mapping exactly which singular assets dominate the local efficient frontier.
---
### Multivariate Dynamics & Temporal Regimes
Understanding how risks evolve over time and across asset classes is paramount. Nexus natively maps high-dimensional data flows into temporal matrices, detecting structural regime shifts before they breach limits.
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/rolling_risk.png" alt="Rolling Risk Regimes" width="800">
</p>
- **Rolling Structural Volatility**: Maps moving-window variance structures directly against overlapping 95% Historical VaR clusters, instantly revealing structural macro-regime changes.
- **Cross-Asset Covariance & Pearson Dependencies**: Instantly maps deep empirical correlation heatmaps to guarantee zero concentration overlaps across distinct asset silos (Equities, Bonds, Crypto, Commodities).
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/correlation_heatmap.png?v=3" alt="Cross-Asset Correlation" width="600">
</p>
### Dispersion & Volatility
- **Standard Deviation & Variance**: The classical unbiased measures of historical risk.
- **Mean Absolute Deviation (MAD)**: A perfectly robust scale metric lacking the extreme parabolic sensitivity of squared variance.
- **Gini Mean Difference**: A powerful absolute deviation measurement utilized in modern asset allocation.
- **L-Scale**: The second L-Moment representing linear combinations of order statistics.
### Downside Asymmetry
- **Semi-Deviation**: A measure of risk that focuses purely on downside variation heavily penalized by investors.
- **Lower Partial Moments (LPM)**: Generalized objective functions for asymmetric downside measurements parameterized by target acceptable return (`MAR`).
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/drawdown_topography.png" alt="Nexus Drawdown Topography" width="800">
</p>
### Tail Exceedance
- **Value at Risk (VaR)**: The industry-standard empirical percentile of the maximum loss over a targeted confidence interval $\alpha$.
- **Conditional VaR (CVaR/Expected Shortfall)**: The expected loss *given* that the VaR threshold has been breached. Structurally coherent.
- **Tail Gini**: A unique generalized formulation merging CVaR with Gini mean difference within extreme domains.
<p align="center">
<img src="https://raw.githubusercontent.com/Anagatam/Nexus/main/docs/assets/tail_risk_metrics.png" alt="Extreme Tail Convexity Breakdown" width="800">
</p>
### Convex Entropic Bounds
- **Entropic Value at Risk (EVaR)**: The tightest coherent upper bound on VaR historically derived strictly from the Chernoff inequality. Extremely responsive to extreme market shocks.
- **Relativistic VaR (RLVaR)**: A massive 3D power-cone deformation scaling Entropic bounds to asymmetric generalized logarithmic divergences.
- **Entropic Drawdown at Risk (EDaR)**: A revolutionary path-dependent risk metric combining geometric Chernoff bounds with historical peak-to-trough waterfall drawdowns.
---
## Unparalleled Solver Routing
Nexus was built to scale from individual traders directly to high-frequency servers natively.
Its generalized convex penalty equations computationally **detect commercial optimization licenses** (like **MOSEK** or **GUROBI** via **CVXPY**).
- If found, it natively routes extreme computations (EVaR, EDaR, RLVaR) through absolute mathematical exponential cones, achieving millisecond precision over millions of market datapoints.
- If not found, it miraculously falls back to high-grade `scipy.optimize.minimize` open-source algorithmic optimization without crashing.
---
## Project principles and design decisions
- **Modularity**: It should be easy to swap out individual components of the analytical process with the user's proprietary improvements.
- **Mathematical Transparency**: All functions are internally documented with strict $\LaTeX$ formulations.
- **Object-Oriented Supremacy**: There is no point in portfolio optimization unless it can be practically applied to real asset matrices easily. The Facade pattern rules.
- **Robustness**: Extensively guarded against arrays of `NaN` fragments and disjointed dimensions.
---
## 🚀 Installation
### Using pip
The primary stable architecture.
```bash
pip install nexus-quant
```
For institutional scaling (which enforces CVXPY tensor integrations; optimally paired with a local MOSEK license instance):
```bash
pip install "nexus-quant[enterprise]"
```
### From source
Clone the repository, navigate to the folder, and install directly using pip:
```bash
git clone https://github.com/Anagatam/Nexus.git
cd Nexus
pip install -e .
```
---
## Testing & Developer Setup
Tests are written natively in `pytest` utilizing deterministic NumPy architectures to completely bypass `yfinance` REST rate limits.
Run the native `Makefile` to instantly configure the repository for contributing:
```bash
make install
make format
make test
```
---
## License
Nexus is distributed freely under the standard **MIT License**. Open-source rules quantitative finance.
**Disclaimer:** Nothing about this project constitutes investment advice, and the author bears no responsibility for your subsequent investment decisions. Please rigorously validate all models statistically in out-of-sample data before committing live capital.
| text/markdown | Nexus Quantitative Architect | architect@nexus-quant.com | null | null | null | null | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Financial and Insurance Industry",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Office/Business :: Financial :: Investment",
"Topic :: Scientific/Engineering :: Mathematics"
] | [] | https://github.com/nexus-quant/nexus | null | >=3.10 | [] | [] | [] | [
"numpy>=1.24.0",
"scipy>=1.10.0",
"pandas>=2.0.0",
"yfinance>=0.2.18",
"cvxpy>=1.3.0; extra == \"enterprise\"",
"mosek>=10.0.0; extra == \"enterprise\"",
"pytest; extra == \"dev\"",
"flake8; extra == \"dev\"",
"black; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.5 | 2026-02-20T14:07:00.758874 | nexus_quant-2.0.1.tar.gz | 19,992 | 3a/ab/c7d04c3b4039202bdeda514c55c788cffd9ff63bb32365f5ad00f7348038/nexus_quant-2.0.1.tar.gz | source | sdist | null | false | 66f865506cfa32382c9f3ff3ba23056b | dd3117b100415faba2a183476b70c64421e3d232bb88cb342af91dd19b537583 | 3aabc7d04c3b4039202bdeda514c55c788cffd9ff63bb32365f5ad00f7348038 | null | [] | 204 |
2.4 | tokenflood | 0.8.0 | Tokenflood is a load testing framework for simulating arbitary loads on instruction-tuned LLMs. | # Tokenflood
Tokenflood is a load testing tool for instruction-tuned LLMs that allows you to
run arbitrary load profiles without needing specific prompt and response data.
**Define desired prompt lengths, prefix lengths, output lengths, and request rates,
and tokenflood simulates this workload for you.**
Tokenflood makes it easy to explore how latency changes when using different providers,
hardware, quantizations, or prompt and output lengths.
Tokenflood uses [litellm](https://www.litellm.ai/) under the hood and supports
[all providers that litellm covers](https://docs.litellm.ai/docs/providers).
> [!CAUTION]
> Tokenflood can generate high costs if configured poorly and used with pay-per-
> token services. Make sure you only test workloads that are within a reasonable budget.
> See the safety section for more information.
### Table of Contents
* [Common Usage Scenarios](#common-usage-scenarios)
* [Example: Assessing the effects of prompt optimizations](#example-1-assessing-the-effects-of-potential-prompt-optimizations)
* [Example: Figure out when people start stealing your latency](#example-2-find-out-when-people-start-stealing-your-latency)
* [Professional Services](#-professional-services-)
* [Installation](#installation)
* [Quick Start](#quick-start)
* [Configuration](#configuration)
* [Endpoint Specifications](#endpoint-specs)
* [Endpoint Examples](#endpoint-examples)
* [Run Suites](#run-suites)
* [Observation Specs](#observation-specs)
* [Heuristic Load Testing Explained](#heuristic-load-testing)
* [Safety](#-safety-)
## Common Usage Scenarios
1. Load testing self-hosted LLMs.
2. Assessing the effects of hardware, quantization, and prompt optimizations on latency, throughput, and costs.
3. Assessing the intraday latency variations of hosted LLM providers for your load types.
4. Assessing and choosing a hosted LLM provider before going into production with them.
### Example 1: Assessing the effects of potential prompt optimizations
The left graph represents the base case, our current prompt parameters: ~3000 input tokens, of which ~1000 are a common prefix that can be cached, and ~60 output tokens.
The right graph represents a hypothetical improvement to prompt parameters: the same 3000 input tokens, but now 2000 common prefix tokens achieved by rearranging or standardizing parts, and a reduction to 45 output tokens.
The result is a more than 50% reduction in latency while at the same time meaningfully increasing amount of prompts that can be served on the same hardware without latency going through the roof.
Tokenflood allows you to find worthwhile goals for prompt parameter improvements before going there.
### Example 2: Find out when people start stealing your latency
Load testing large providers does not really make sense if you value your money as their datacenters are huge, shared resources. While a single company or user usually does not have much effect on them,
these shared resources are subject to intra-day latency variations, oftentimes coinciding with daily business hours.
Here we see that once business starts in the US latency of this openai-hosted model drops by 500-1000ms for our chosen prompt parameters.
Tokenflood allows you to assess these patterns before going into production with a vendor.
## 🛠️ Professional Services 🛠️
If you are looking for professional support to
* optimize your LLM accuracy, latency, throughput, or costs
* fine-tune open models for your use case
* improve your LLM observability
* design and build custom AI systems
feel free to reach out to me at thomas@werkmeister.me or on [linkedin](https://www.linkedin.com/in/twerkmeister/).
## Installation
```bash
pip install tokenflood
```
## Quick Start
For a quick start, make sure that vllm is installed, and you serve a small model:
```bash
pip install vllm
vllm serve HuggingFaceTB/SmolLM-135M-Instruct
```
Afterward, create the basic config files and do a first run:
```bash
# This creates tiny starter files: run_suite.yml, observation_spec.yml and endpoint_spec.yml
tokenflood init
# Afterwards you can inspect those files, and then do a load test
tokenflood run run_suite.yml endpoint_spec.yml
# Or observe the endpoint
tokenflood observe observation_spec.yml endpoint_spec.yml
# start the data visualisation frontend
tokenflood viz
```
## Configuration
### Endpoint Specs
With the endpoint spec file you can determine the target of the load test.
Tokenflood uses [litellm](https://www.litellm.ai/) under the hood and supports
[all providers that litellm covers](https://docs.litellm.ai/docs/providers).
Here you see the example endpoint spec file from the quick start:
```yaml
provider: hosted_vllm
model: HuggingFaceTB/SmolLM-135M-Instruct
base_url: http://127.0.0.1:8000/v1
api_key_env_var: null
deployment: null
extra_headers: {}
```
Explanation of the parameters:
* `provider`: is the provider parameter used by litellm and is used to determine how to exactly interact with the endpoint as different providers have different APIs.
* `model`: the specific model to use at the given endpoint.
* `base_url`: important if you are self-hosting or using an endpoint in a specific region of a provider.
* `api_key_env_var`: The name of the environment variable to use as the API key. If you specify it, it allows you to manage multiple API keys for the same provider for different regions without changing env files: such as `AZURE_KEY_FRANKFURT` and `AZURE_KEY_LONDON`.
* `deployment`: Required for some providers such as azure.
* `extra_headers`: Can be useful for certain providers to select models.
Tokenflood passes all these parameters right through to litellm's completion call.
To get a better understanding, it's best to have a look at [the official documentation of the litellm completion call](https://docs.litellm.ai/docs/completion/input).
#### Endpoint Examples
##### Self-hosted VLLM
```yaml
provider: hosted_vllm
model: meta-llama/Llama-3.1-8B-Instruct
base_url: http://127.0.0.1:8000/v1
```
##### Openai
```yaml
provider: openai
model: gpt-4o-mini
```
Env vars: `OPENAI_API_KEY`
##### Bedrock
```yaml
provider: bedrock
model: anthropic.claude-3-sonnet-20240229-v1:0
```
Env vars: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION_NAME`
##### AWS Sagemaker Inference Endpoints
```yaml
provider: sagemaker_chat
model: your-sagemaker-endpoint
```
Env vars: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION_NAME`
##### Azure
```yaml
provider: azure
deployment: gpt-4o
model: gpt-4o
api_version: 2024-06-01
api_base: https://my-azure-url.openai.azure.com/
```
Env vars: `AZURE_API_KEY`
##### Gemini
```yaml
provider: gemini
model: gemini-2.5-flash-lite-preview-09-2025
```
Env vars: `GEMINI_API_KEY`
##### Anthropic
```yaml
provider: anthropic
model: claude-3-5-sonnet-20240620
```
Env vars: `ANTHROPIC_API_KEY`
### Run Suites
With a run suite you define a load test that you want to run. Each test can have multiple
phases with a different number of requests per second. All phases share the same length in
seconds and the type of loads that are being sent.
Here is the run suite that is being created for you upon calling `tokenflood init`:
```yaml
name: starter
requests_per_second_rates: # Defines the phases with the different request rates
- 1.0
- 2.0
test_length_in_seconds: 10 # each phase is 10 seconds long
load_types: # This run suite has two load types with equal weight
- prompt_length: 512 # prompt length in tokens
prefix_length: 128 # prompt prefix length in tokens
output_length: 32 # output length in tokens
weight: 1 # sampling weight for this load type
- prompt_length: 640
prefix_length: 568
output_length: 12
weight: 1
budget:
input_tokens: 100000 # the maximum number of input tokens this test is allowed to use - prevents any load configuration that would use more than this from starting
output_tokens: 10000 # the maximum number of output tokens this test is allowed to use - prevents any load configuration that would use more than this from starting
error_limit: 0.3 # the fraction of errors in requests that are acceptable for the last 30 requests. The test will end once this limit is breached.
task: # The task tokenflood uses to generate a lot of tokens which we can truncate using the max token parameters - makes sure we do not produce too few tokens!
task: 'Task: Count up to 1000 naming each individual number like this: 1 2 3 4'
token_set: # The 1-token strings tokenflood uses to fill up the prompt and prefix up to the desired length
tokens:
- ' A'
- ' B'
- ' C'
- ' D'
- ' E'
- ' F'
- ' G'
- ' H'
- ' I'
- ' J'
- ' K'
- ' L'
- ' M'
- ' N'
- ' O'
- ' P'
- ' Q'
- ' R'
- ' S'
- ' T'
- ' U'
- ' V'
- ' W'
- ' X'
- ' Y'
- ' Z'
```
### Observation Specs
With an observation spec you define a longer running observation of an endpoint.
You can define a total length of your observation in hours and a polling interval
in minutes as well as how many and what type of requests you want to send at those
points in time.
Here is the observation spec that is generated by running `tokenflood init`:
```yaml
name: starter
duration_hours: 1.0 # total test length: 1 hour
polling_interval_minutes: 15.0 # send requests every 15 minutes
load_type: # observation runs just have one load type
prompt_length: 512 # prompt length in tokens
prefix_length: 128 # prompt prefix length in tokens
output_length: 32 # output length in tokens
num_requests: 5 # how many requests to send at the start of an interval
within_seconds: 2.0 # within how many seconds to send the requests at the start of an interval (useful to manage rate limits)
budget:
input_tokens: 1000000 # the maximum number of input tokens this test is allowed to use - prevents any load configuration that would use more than this from starting
output_tokens: 10000 # the maximum number of output tokens this test is allowed to use - prevents any load configuration that would use more than this from starting
task: # The task tokenflood uses to generate a lot of tokens which we can truncate using the max token parameters - makes sure we do not produce too few tokens!
task: 'Task: Count up to 1000 naming each individual number like this: 1 2 3 4'
token_set: # The 1-token strings tokenflood uses to fill up the prompt and prefix up to the desired length
tokens:
- ' A'
- ' B'
- ' C'
- ' D'
- ' E'
- ' F'
- ' G'
- ' H'
- ' I'
- ' J'
- ' K'
- ' L'
- ' M'
- ' N'
- ' O'
- ' P'
- ' Q'
- ' R'
- ' S'
- ' T'
- ' U'
- ' V'
- ' W'
- ' X'
- ' Y'
- ' Z'
```
## Heuristic Load Testing
Tokenflood does not need specific prompt data to run tests. Instead, it only needs
metadata about the prompt and task: prompt length, prefix length, and output lengths.
All counted in tokens. This allows for swift testing of alternative configurations and
loads. Changing the token counts in the load types is a matter of seconds as opposed
to having to adjust implementations and reobserving prompts of a system. Additionally,
you can make sure to get exactly the desired output profile across all models and
configurations, allowing for direct comparison between them.
### How it works
Tokenflood uses sets of strings that correspond to a single token in most tokenizers,
such as a space plus a capital letter. Sampling from this set of single token strings,
tokenflood generates the input prompt. The defined prefix length will be non-random.
Finally, a task that usually generates a long answer is appended. In combination with
setting the maximum completion tokens for generation, tokenflood achieves the desired
output length.
### Why it works
This type of heuristic testing creates reliable data because the processing time of a
non-reasoning LLM only depends on the length of input and output and any involved caching
mechanisms.
### Failures of the heuristic
Heuristic load testing comes with the risk of not perfectly achieving the desired token
counts for specific models. If that happens, tokenflood will warn you during a run if
any request diverges more than 10% from the expected input or output token lengths. The
visualisation frontend also shows absolute and relative token errors.
> [!IMPORTANT]
> You can specify the prefix length, however, whether the prefix is used will depend on the
> specific endpoint and its configuration. Some providers, like OpenAI, will only start to
> use prefix caching once your total prompt length exceeds 1024 tokens. Additionally,
> it seems litellm does not always record the usage of prefix caching. When
> using vllm as the inference server, it never reports any cached tokens. At the same
> time, one can see a big difference in latency between using and not using prefix
> caching despite the cached tokens not being reported properly. Due to this issue,
> tokenflood currently does not warn when the desired prefix tokens diverge from the
> measured ones.
## 🚨 Safety 🚨
Using tokenflood can result in high token spending. To prevent negative surprises,
tokenflood has additional safety measurements:
1. Tokenflood always tries to estimate the used tokens for the test upfront and asks you to confirm the start of the tests after seeing the estimation.
2. There are additional run suite variables that determine the maximum allowed input and output token budget for the test. A test whose token usage estimate exceeds those limits will not be started.
3. Tokenflood won't start a run were the first warm-up request fails, e.g., due to API key misconfiguration
4. Tokenflood will end a run once the error rate exceeds 30% for the last 30 requests.
Still, these measures do not provide perfect protection against misconfiguration.
Always be careful when using tokenflood.
## 🤝 Contributing
We welcome contributions!
If you'd like to add new features, fix bugs, or improve the documentation:
1. Fork the repository
2. Install including dev dependencies
```
poetry install --all-groups
```
3. Create a feature branch:
```
git checkout -b feature/my-improvement
```
4. Make your changes and add tests if applicable
5. Run linting and tests locally to ensure everything works:
```
make lint
make test
```
6. Submit a pull request with a clear description of your improvement
If you plan a major change (e.g., new test type or provider integration), please open an issue first to discuss it.
| text/markdown | Thomas Werkmeister | thomas@werkmeister.me | null | null | null | null | [
"Programming Language :: Python :: 3",
"Operating System :: OS Independent"
] | [] | null | null | <3.14,>=3.11 | [] | [] | [] | [
"aiofiles<25.0,>=22.0",
"boto3<2.0.0,>=1.42.53",
"gradio<7.0.0,>=6.1.0",
"litellm<2.0.0,>=1.78.0",
"numpy>=2.2.6",
"pandas<3.0.0,>=2.3.3",
"plotly<7.0.0,>=6.5.0",
"pydantic<3.0.0,>=2.12.2",
"python-dotenv<2.0.0,>=1.1.1",
"rich<15.0.0,>=14.2.0",
"tokenizers<0.23.0,>=0.22.1",
"tqdm<5.0.0,>=4.67.1"
] | [] | [] | [] | [
"Homepage, https://github.com/twerkmeister/tokenflood",
"Issues, https://github.com/twerkmeister/tokenflood/issues"
] | twine/6.2.0 CPython/3.11.10 | 2026-02-20T14:06:55.160316 | tokenflood-0.8.0.tar.gz | 31,479 | c2/fc/653343b96b120ffd6c80344ead2531c50e60ec84f80d691be2377359ff1c/tokenflood-0.8.0.tar.gz | source | sdist | null | false | a69b17763e1ce7b5fd0af50f2ca2c8f9 | f92b0fba66b20256d7f6a2bd160eec32e2db3e0f79cc2a040b0413a038cfb2c0 | c2fc653343b96b120ffd6c80344ead2531c50e60ec84f80d691be2377359ff1c | MIT | [
"LICENSE"
] | 204 |
2.4 | vd-dlt-salesforce-schema | 0.1.2 | Salesforce connector schema and defaults for vd-dlt | # vd-dlt-salesforce-schema
Schema and defaults for Salesforce connector.
## Installation
```bash
pip install vd-dlt-salesforce-schema
```
Typically installed as a dependency of vd-dlt-salesforce.
| text/markdown | null | VibeData <info@vibedata.dev> | null | null | null | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Topic :: Database"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"pyyaml>=6.0"
] | [] | [] | [] | [
"Homepage, https://github.com/accelerate-data/vd-dlt-connectors",
"Repository, https://github.com/accelerate-data/vd-dlt-connectors"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:06:52.512260 | vd_dlt_salesforce_schema-0.1.2.tar.gz | 3,597 | 87/d9/1ec2b2eb126ea32a57fce8ffae90f533037a8da330980b9791225420abaf/vd_dlt_salesforce_schema-0.1.2.tar.gz | source | sdist | null | false | 9db41db0c194038fdb4828a5cd6e4194 | a78f9277ff26fd274f03446626cd1b2558f972aa39e13ffce918bd0e91ae8d49 | 87d91ec2b2eb126ea32a57fce8ffae90f533037a8da330980b9791225420abaf | MIT | [] | 224 |
2.4 | j-perm | 1.6.0 | json permutation library | # J-Perm
A composable JSON transformation DSL with a powerful, extensible architecture.
J-Perm lets you describe data transformations as **executable specifications** — a list of steps that can be applied to input documents. It supports
JSON Pointer addressing with slicing (arrays and strings), template interpolation with `${...}` syntax, special constructs (`$ref`, `$eval`, `$cast`, `$raw`), logical and comparison operators (`$and`, `$or`, `$not`), comparison operators (6 operators plus `$in` and `$exists`), mathematical operations (6 operators), comprehensive string manipulation (11 operations), regular expressions (5 operations), user-defined functions (`$def`, `$func`, `$raise`) with loop/function control flow (`$break`, `$continue`, `$return`), error handling (`try-except-finally`), and a rich set of built-in operations — all with configurable security limits to prevent DoS attacks.
---
## Quick Example
```python
from j_perm import build_default_engine
engine = build_default_engine()
# Source data
source = {
"users": [
{"name": "Alice", "age": "17"},
{"name": "Bob", "age": "22"}
]
}
# Transformation spec using foreach and the &: prefix for the loop variable
spec = {
"op": "foreach",
"in": "/users",
"as": "item",
"do": {
"op": "if",
"cond": "${?args.item.age >= `18`}",
"then": {"/adults[]": "&:/item"},
},
}
result = engine.apply(spec, source=source, dest={})
# → {"adults": [{"name": "Bob", "age": "22"}]}
```
---
## Installation
```bash
pip install j-perm
```
*(or copy the package into your project)*
---
## Architecture Overview
J-Perm is built on a **pipeline architecture** with two main levels:
```
┌─────────────────────────────────────────────────────────┐
│ spec (user input) │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ STAGES (batch preprocessing, priority order) │ │
│ │ • ShorthandExpansion → expand ~delete, etc │ │
│ │ • YourCustomStage │ │
│ └──────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ List[step] │
│ │ │
│ ▼ for each step: │
│ ┌──────────────────────────────────────────────────┐ │
│ │ MIDDLEWARES (per-step, priority order) │ │
│ │ • Validation, logging, etc. │ │
│ └──────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ REGISTRY (hierarchical dispatch tree) │ │
│ │ • SetHandler, CopyHandler, ForeachHandler, ... │ │
│ └──────────────────────────────────────────────────┘ │
│ │ │
│ │ handlers call ctx.engine.process_value(...) │
│ └─────────────────────────────────────┐ │
│ ▼ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ VALUE PIPELINE (stabilization loop) │ │
│ │ • SpecialResolveHandler ($ref, $eval) │ │
│ │ • TemplSubstHandler (${...}) │ │
│ │ • RecursiveDescentHandler (containers) │ │
│ │ • IdentityHandler (scalars) │ │
│ └──────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
```
### Core Components
| Component | Purpose |
|------------------------|------------------------------------------------------------------|
| **Engine** | Orchestrates pipelines, manages context, runs stabilization loop |
| **Pipeline** | Runs stages → middlewares → registry dispatch for each step |
| **StageRegistry** | Tree of batch preprocessors (run-all, priority order) |
| **ActionTypeRegistry** | Tree of action handlers (first-match or run-all) |
| **ValueResolver** | Abstraction for addressing (JSON Pointer implementation) |
---
## Core API
### Building an Engine
```python
from j_perm import build_default_engine
# Default engine with all built-ins and default security limits
engine = build_default_engine()
# Custom specials (None = use defaults: $ref, $eval, $cast, $and, $or, $not, comparison, math, string, regex)
engine = build_default_engine(
specials={"$ref": my_ref_handler, "$custom": my_handler},
casters={"int": lambda x: int(x), "json": lambda x: json.loads(x)}, # Used in ${type:...} AND $cast
jmes_options=jmespath.Options(custom_functions=CustomFunctions())
)
# Custom security limits (see Security and Limits section)
engine = build_default_engine(
max_operations=10_000,
max_function_recursion_depth=50,
max_loop_iterations=1_000,
regex_timeout=1.0,
pow_max_exponent=100,
# ... see factory.py for all available limits
)
# Logging / debugging (see Logging and Debugging section)
engine = build_default_engine(
trace_logging=True, # DEBUG-log every executed step
trace_repr_max=None, # show steps without truncation (default: 200)
)
```
### Applying Transformations
```python
result = engine.apply(
spec, # DSL script (dict or list)
source=source, # Source context (for pointers, templates)
dest=dest, # Initial destination (default: {})
)
```
**Returns:** Deep copy of the final `dest` after all transformations.
---
## Security and Limits
J-Perm includes comprehensive protection against DoS attacks through configurable limits. All limits can be customized via `build_default_engine()` parameters.
### Global Limits
| Parameter | Default | Description |
|-----------|---------|-------------|
| `max_operations` | 1,000,000 | Maximum total operations across entire transformation |
| `max_function_recursion_depth` | 100 | Maximum depth for recursive function calls |
**Example: Preventing infinite recursion**
```python
engine = build_default_engine(max_function_recursion_depth=50)
# This will raise RuntimeError if recursion exceeds 50 levels
spec = [
{"$def": "factorial", "params": ["n"], "body": [
{"op": "if", "cond": {"$eq": [{"$ref": "&:/n"}, 0]},
"then": [{"/result": 1}],
"else": [{"/result": {"$mul": [
{"$ref": "&:/n"},
{"$func": "factorial", "args": [{"$sub": [{"$ref": "&:/n"}, 1]}]}
]}}]}
], "return": "/result"},
{"/output": {"$func": "factorial", "args": [100]}} # Too deep!
]
```
### Loop and Iteration Limits
| Parameter | Default | Description |
|-----------|---------|-------------|
| `max_loop_iterations` | 10,000 | Maximum iterations for `while` loops |
| `max_foreach_items` | 100,000 | Maximum items to process in `foreach` |
**Example: Preventing infinite loops**
```python
engine = build_default_engine(max_loop_iterations=1000)
# This will raise RuntimeError if loop exceeds 1000 iterations
spec = {
"op": "while",
"cond": {"$lt": [{"$ref": "@:/counter"}, 999999]}, # Never stops!
"do": [{"/counter": {"$add": [{"$ref": "@:/counter"}, 1]}}]
}
```
### Mathematical Operation Limits
| Parameter | Default | Description |
|-----------|---------|-------------|
| `pow_max_base` | 1,000,000 | Maximum base value for `$pow` |
| `pow_max_exponent` | 1,000 | Maximum exponent value for `$pow` |
| `mul_max_operand` | 1,000,000,000 | Maximum numeric operand in `$mul` |
| `mul_max_string_result` | 1,000,000 | Maximum string length from `$mul` (e.g., `"x" * n`) |
| `add_max_number_result` | 1e15 | Maximum numeric result from `$add` |
| `add_max_string_result` | 100,000,000 | Maximum string length from `$add` (concatenation) |
| `sub_max_number_result` | 1e15 | Maximum numeric result from `$sub` |
**Example: Preventing CPU exhaustion**
```python
engine = build_default_engine(
pow_max_base=1000,
pow_max_exponent=10
)
# This will raise ValueError: exponent exceeds limit
spec = {"/result": {"$pow": [2, 1000]}} # 2^1000 would consume massive CPU
# This will raise ValueError: base exceeds limit
spec = {"/result": {"$pow": [999999, 2]}}
```
### String Operation Limits
| Parameter | Default | Description |
|-----------|---------|-------------|
| `str_max_split_results` | 100,000 | Maximum results from `$str_split` |
| `str_max_join_result` | 10,000,000 | Maximum length of `$str_join` result |
| `str_max_replace_result` | 10,000,000 | Maximum length of `$str_replace` result |
**Example: Preventing memory exhaustion**
```python
engine = build_default_engine(str_max_split_results=1000)
# This will raise ValueError if split produces more than 1000 results
spec = {"/words": {"$str_split": {"string": "${/large_text}", "delimiter": " "}}}
```
### Regex Protection (ReDoS Prevention)
| Parameter | Default | Description |
|-----------|---------|-------------|
| `regex_timeout` | 2.0 | Timeout in seconds for regex operations |
| `regex_allowed_flags` | None | Bitmask of allowed regex flags (None = default safe flags: IGNORECASE, MULTILINE, DOTALL, VERBOSE, ASCII; -1 = all flags allowed) |
**Example: Preventing ReDoS attacks**
```python
engine = build_default_engine(regex_timeout=1.0)
# This will raise TimeoutError if regex takes more than 1 second
spec = {
"/result": {
"$regex_match": {
"pattern": "(a+)+b", # Catastrophic backtracking pattern
"string": "aaaaaaaaaaaaaaaaaaaaaaaac" # No match, tries all combinations
}
}
}
```
**Restricting regex flags:**
```python
import re
# Only allow case-insensitive and multiline flags
engine = build_default_engine(
regex_allowed_flags=re.IGNORECASE | re.MULTILINE
)
# This will raise ValueError: prohibited regex flags
spec = {
"/result": {
"$regex_match": {
"pattern": "test",
"string": "TEST",
"flags": re.DOTALL # Not allowed!
}
}
}
# Allow all flags (not recommended for untrusted input)
engine = build_default_engine(regex_allowed_flags=-1)
```
### Customizing Limits
All limits can be configured when building the engine:
```python
from j_perm import build_default_engine
# Conservative limits for untrusted input
secure_engine = build_default_engine(
max_operations=10_000,
max_function_recursion_depth=10,
max_loop_iterations=100,
max_foreach_items=1_000,
regex_timeout=0.5,
pow_max_exponent=100,
str_max_join_result=100_000,
)
# Relaxed limits for trusted environments
permissive_engine = build_default_engine(
max_operations=10_000_000,
max_function_recursion_depth=1000,
max_loop_iterations=1_000_000,
regex_timeout=10.0,
)
```
**Best practices:**
- Use **conservative limits** when processing untrusted user input
- Use **permissive limits** for internal data transformations
- **Monitor** `max_operations` counter to detect suspicious activity
- **Test** your transformations with realistic data sizes
- **Tune** limits based on your specific use case
---
## Logging and Debugging
J-Perm uses Python's standard `logging` module under the logger name **`j_perm`**.
### Error Logging (Language Call Stack)
When an unhandled exception escapes `Engine.apply()`, j-perm automatically logs the **language-level call stack** at `ERROR` level — showing exactly which operations were executing when the error occurred, without Python internals.
```python
import logging
logging.basicConfig(level=logging.ERROR)
engine = build_default_engine()
engine.apply(
spec=[
{"op": "foreach", "in": "/users", "as": "user", "do": [
{"op": "if", "cond": True, "then": [
{"op": "set", "path": "/result/-", "value": {"$ref": "/missing/path"}}
]}
]}
],
source={"users": ["Alice"]},
dest={},
)
```
Output:
```
ERROR j_perm: j-perm execution failed: KeyError: 'missing'
Language call stack (innermost last):
#1 {'op': 'foreach', 'in': '/users', 'as': 'user', 'do': [1 items]}
#2 {'op': 'if', 'cond': True, 'then': [1 items]}
#3 {'op': 'set', 'path': '/result/-', 'value': {'$ref': '/missing/path'}}
```
**Important:** Errors caught by `{"op": "try", ...}` inside the spec are **not logged** — only errors that propagate all the way out of `apply()` appear in the log. Control flow signals (`$break`, `$continue`, `$return`) are never treated as errors.
The call stack is also attached to the exception itself for programmatic access:
```python
try:
engine.apply(spec, source=src, dest={})
except Exception as e:
stack = getattr(e, "_j_perm_lang_stack", None)
if stack:
for i, frame in enumerate(stack, 1):
print(f" #{i} {frame}")
```
### Trace Logging (Full Execution Log)
To log every step as it executes — even without errors — enable `trace_logging`:
```python
import logging
logging.basicConfig(level=logging.DEBUG)
engine = build_default_engine(trace_logging=True)
engine.apply(
spec=[
{"op": "set", "path": "/name", "value": "Alice"},
{"op": "foreach", "in": "/tags", "as": "tag", "do": [
{"op": "set", "path": "/out/-", "value": {"$ref": "&:/tag"}}
]},
],
source={"tags": ["x", "y"]},
dest={},
)
```
Output (each step indented by nesting depth):
```
DEBUG j_perm: → {'op': 'set', 'path': '/name', 'value': 'Alice'}
DEBUG j_perm: → {'op': 'foreach', 'in': '/tags', 'as': 'tag', 'do': [1 items]}
DEBUG j_perm: → {'op': 'set', 'path': '/out/-', 'value': {'$ref': '&:/tag'}}
DEBUG j_perm: → {'op': 'set', 'path': '/out/-', 'value': {'$ref': '&:/tag'}}
```
### Controlling Step Representation Length
By default, each step is truncated to 200 characters in the call stack and trace output. Use `trace_repr_max` to change this:
```python
# Increase the limit
engine = build_default_engine(trace_logging=True, trace_repr_max=500)
# Disable truncation — show every step in full
engine = build_default_engine(trace_logging=True, trace_repr_max=None)
```
| Parameter | Default | Description |
|-----------|---------|-------------|
| `trace_logging` | `False` | Emit `DEBUG` log for every executed step |
| `trace_repr_max` | `200` | Max characters per step representation. `None` = no limit |
### Value Resolution Tracing
To see how each value is resolved through the value pipeline (template substitution, `$ref`, `$cast`, etc.), enable the `j_perm.values` sub-logger at `DEBUG` level:
```python
import logging
logging.basicConfig(level=logging.DEBUG)
engine = build_default_engine(trace_logging=True) # also enable step trace for full picture
engine.apply(
spec=[{"op": "set", "path": "/greeting", "value": "Hello, ${/name}!"}],
source={"name": "Alice"},
dest={},
)
```
Output — `j_perm` shows the step, `j_perm.values` shows each transformation:
```
DEBUG j_perm: → {'op': 'set', 'path': '/greeting', 'value': 'Hello, ${/name}!'}
DEBUG j_perm.values: 'Hello, ${/name}!' → 'Hello, Alice!'
```
Value tracing is independent of `trace_logging` — you can enable it alone:
```python
import logging
# Enable only value resolution tracing, suppress step-level trace
logging.getLogger("j_perm.values").setLevel(logging.DEBUG)
logging.getLogger("j_perm").setLevel(logging.ERROR) # suppress step trace
```
Each line shows one stabilization pass: `input → output`. Multi-step resolution (e.g., `$ref` returning a template that itself gets substituted) appears as multiple lines, indented to the current call depth.
### Named Pipeline Tracing
Each named pipeline gets its own logger: **`j_perm.pipeline.<name>`**. This lets you turn on tracing for all pipelines at once or zoom in on a specific one.
```python
import logging
# All named pipelines
logging.getLogger("j_perm.pipeline").setLevel(logging.DEBUG)
# Only the "normalize" pipeline
logging.getLogger("j_perm.pipeline.normalize").setLevel(logging.DEBUG)
# Silence a specific pipeline while keeping others
logging.getLogger("j_perm.pipeline.verbose_one").setLevel(logging.WARNING)
```
To produce step-level output inside a named pipeline, create it with `track_execution=True`:
```python
from j_perm import Pipeline, ActionTypeRegistry, ActionNode
my_reg = ActionTypeRegistry()
# ... register handlers ...
my_pipeline = Pipeline(registry=my_reg, track_execution=True)
engine.register_pipeline("normalize", my_pipeline)
```
When `run_pipeline("normalize", ...)` is called, the pipeline's logger emits a `→ [pipeline:normalize]` entry, and if `track_execution=True`, each step follows indented relative to the caller's depth:
```
DEBUG j_perm: → {'op': 'foreach', 'in': '/items', 'as': 'item', 'do': [1 items]}
DEBUG j_perm.pipeline.normalize: → [pipeline:normalize]
DEBUG j_perm.pipeline.normalize: → {'op': 'set', 'path': '/value', 'value': ...}
```
On error, the call stack (including both the outer context and the pipeline's own steps) is logged at `ERROR` level to `j_perm.pipeline.<name>`.
### Logger Hierarchy
J-Perm uses four loggers, all configurable independently via Python's standard `logging` module:
| Logger | Level | When active |
|--------|-------|-------------|
| `j_perm` | `ERROR` | Unhandled error — logs language call stack |
| `j_perm` | `DEBUG` | Step trace (requires `trace_logging=True` on engine) |
| `j_perm.values` | `DEBUG` | Value resolution steps in `process_value` |
| `j_perm.pipeline.<name>` | `ERROR` | Named pipeline error — logs call stack |
| `j_perm.pipeline.<name>` | `DEBUG` | Named pipeline step trace (requires `track_execution=True` on pipeline) |
All `j_perm.pipeline.*` loggers are children of `j_perm.pipeline`, which is itself a child of `j_perm` — so the standard Python logger hierarchy applies:
```python
import logging
# Everything from j-perm (step trace + value trace + all pipeline traces)
logging.getLogger("j_perm").setLevel(logging.DEBUG)
# Only errors, no trace noise
logging.getLogger("j_perm").setLevel(logging.ERROR)
# Suppress all j-perm logging
logging.getLogger("j_perm").setLevel(logging.CRITICAL)
# Step trace only, no value noise
logging.getLogger("j_perm").setLevel(logging.DEBUG)
logging.getLogger("j_perm.values").setLevel(logging.WARNING)
# All named pipeline traces, but not main-pipeline step trace
logging.getLogger("j_perm").setLevel(logging.WARNING)
logging.getLogger("j_perm.pipeline").setLevel(logging.DEBUG)
# Only one specific pipeline
logging.getLogger("j_perm.pipeline").setLevel(logging.WARNING)
logging.getLogger("j_perm.pipeline.normalize").setLevel(logging.DEBUG)
```
---
## Features
### 1. JSON Pointer Addressing
J-Perm uses **RFC 6901 JSON Pointer** with extensions:
```python
from j_perm import PointerResolver
resolver = PointerResolver()
# Basic pointers
resolver.get("/users/0/name", data) # → "Alice"
# Root references (work on scalars too!)
resolver.get(".", 42) # → 42
resolver.get("/", "text") # → "text"
# Parent navigation
resolver.get("/a/b/../c", data) # → data["a"]["c"]
# Slices (work on lists and strings)
resolver.get("/items[1:3]", data) # → [item1, item2] for lists
resolver.get("/text[0:5]", {"text": "hello world"}) # → "hello" for strings
resolver.get("/text[-5:]", {"text": "hello world"}) # → "world" (negative indices)
# Append notation
resolver.set("/items/-", data, "new") # Append to list
```
**Key feature:** Unlike standard JSON Pointer, `PointerResolver` works on **any type** (scalars, lists, dicts) for root references.
#### Data Source Prefixes
J-Perm supports **prefixes** to specify which context to read from:
| Prefix | Source | Description |
|--------|--------|-------------|
| `/path` or `_:/path` | **source** | Read from the immutable source document |
| `@:/path` | **dest** | Read from the destination being built |
| `&:/path` | **args** | Read from `temp_read_only` — function arguments, loop variables, error info |
| `!:/path` | **temp** | Read from `temp` — mutable scratch space, not in final output |
The `&:` prefix is the standard way to access:
- **Function parameters** inside `$def` bodies
- **Loop variables** inside `foreach` `do` blocks
- **Error info** (`_error_message`, `_error_type`) inside `try` `except` blocks
**Example: Accessing dest in templates**
```python
# Build incrementally, referencing previous values
spec = [
{"/name": "Alice"},
{"/greeting": "Hello, ${@:/name}!"} # Reference dest value
]
result = engine.apply(spec, source={}, dest={})
# → {"name": "Alice", "greeting": "Hello, Alice!"}
```
**Example: Function parameters via &:**
```python
spec = [
{
"$def": "greet",
"params": ["name"],
"body": [{"/msg": "Hello, ${&:/name}!"}],
"return": "/msg",
},
{"/result": {"$func": "greet", "args": ["World"]}},
]
result = engine.apply(spec, source={}, dest={})
# → {"result": "Hello, World!"}
```
**Example: Loop variable via &:**
```python
spec = {
"op": "foreach",
"in": "/items",
"as": "item",
"do": {"/out[]": "&:/item"},
}
result = engine.apply(spec, source={"items": [1, 2, 3]}, dest={})
# → {"out": [1, 2, 3]}
```
---
### 2. Template Interpolation (`${...}`)
Templates are resolved by `TemplSubstHandler` in the value pipeline.
#### JSON Pointer lookup
```python
"${/user/name}" # → Resolve pointer from source
"${@:/total}" # → Read from dest
"${&:/param_name}" # → Read function argument / loop variable
"${!:/scratch}" # → Read from temp scratch space
"${_:/user/name}" # → Same as ${/user/name} (source alias)
```
#### Type casters (built-in)
```python
"${int:/age}" # → int(value)
"${float:/price}"
"${bool:/flag}" # → bool(int(value)) if int/str, else bool(value)
"${str:/id}"
```
**Note:** Type casters can also be used via the `$cast` construct (see Special Constructs section).
#### JMESPath queries
```python
"${?source.items[?price > `10`].name}" # → Query source with JMESPath
"${?dest.total}" # → Query destination
"${?add(dest.x, source.y)}" # → Mix source and dest
"${?args.item.age >= `18`}" # → Query function arg / loop variable
"${?temp.scratch}" # → Query temp scratch space
```
**Built-in JMESPath functions:** `add(a, b)`, `subtract(a, b)`
**JMESPath data namespaces:**
| Namespace | Context field | Description |
|-----------|---------------|-------------|
| `source.*` | `ctx.source` | Source document |
| `dest.*` | `ctx.dest` | Destination being built |
| `args.*` | `ctx.temp_read_only` | Function args, loop vars, error info |
| `temp.*` | `ctx.temp` | Mutable scratch space |
#### Nested templates
```python
"${${/path_to_field}}" # → Resolve inner template first
```
#### Escaping
```text
$${ → ${ (literal)
$$ → $ (literal)
```
---
### 3. Special Constructs
Special values are resolved by `SpecialResolveHandler`.
#### `$ref` — Reference resolution
```json
{
"$ref": "/path/to/value",
"$default": "fallback"
}
```
- Resolves pointer from **source** context (supports all prefixes: `@:`, `&:`, `!:`, `_:`)
- Returns deep copy (no aliasing)
- Supports `$default` fallback
#### `$eval` — Nested evaluation
```json
{
"$eval": [
{
"op": "set",
"path": "/x",
"value": 1
}
],
"$select": "/x"
}
```
- Executes nested DSL with `dest={}`
- Optionally selects sub-path from result
#### `$cast` — Type casting
```json
{
"$cast": {
"value": "42",
"type": "int"
}
}
```
- Applies a registered type caster to a value
- `value` — the value to cast (supports templates, `$ref`, etc.)
- `type` — name of the registered caster (built-in: `int`, `float`, `bool`, `str`)
- Alternative to template syntax `${type:...}`
**Examples:**
```python
# Cast string to int
{"/age": {"$cast": {"value": "25", "type": "int"}}}
# Cast with template substitution
{"/count": {"$cast": {"value": "${/raw_count}", "type": "int"}}}
# Cast with $ref
{"/price": {"$cast": {"value": {"$ref": "/data/price"}, "type": "float"}}}
# Dynamic type selection
{"/result": {"$cast": {"value": "123", "type": "${/target_type}"}}}
```
**Custom casters:**
```python
# Define custom caster
def custom_upper(x):
return str(x).upper()
engine = build_default_engine(casters={"upper": custom_upper})
# Use in spec
{"/name": {"$cast": {"value": "alice", "type": "upper"}}} # → "ALICE"
```
#### `$raw` — Return a literal without processing
`$raw` has two forms:
**Wrapper construct** — returns the value as-is, preventing all value-pipeline evaluation:
```json
{"$raw": {"$ref": "/not/evaluated"}}
{"$raw": "hello ${not_substituted}"}
{"$raw": [{"$ref": "/a"}, {"$ref": "/b"}]}
```
The wrapped value is never passed through template substitution, `$ref` resolution, or any other pipeline stage. Use this to store construct-shaped data as a literal.
**Flag on any construct** — add `"$raw": true` to stop the stabilisation loop after the construct resolves:
```json
{"$ref": "/path", "$raw": true}
{"$func": "myFunc", "$raw": true}
{"$add": [1, 2], "$raw": true}
```
Without the flag, `process_value` keeps iterating until the result stabilises — so if `$ref` returns a value that itself contains a `$ref`, that too will be resolved. With `"$raw": true`, the loop stops after the first resolution and returns the result as-is.
**Example — preventing chain resolution:**
```python
# source["/a"] contains another construct
source = {"a": {"$ref": "/b"}, "b": "final"}
# Without $raw: True — both hops resolved
spec = {"/result": {"$ref": "/a"}}
# → {"result": "final"}
# With $raw: True — only first hop resolved
spec = {"/result": {"$ref": "/a", "$raw": True}}
# → {"result": {"$ref": "/b"}}
```
**Example — storing a construct as a literal:**
```python
spec = [
# Store a construct literally (not evaluated)
{"/template": {"$raw": {"$ref": "/data"}}},
# Later retrieve it — still unevaluated
{"/copy": {"$ref": "@:/template", "$raw": True}},
]
result = engine.apply(spec, source={"data": "value"}, dest={})
# → {"template": {"$ref": "/data"}, "copy": {"$ref": "/data"}}
```
#### `$and` — Logical AND with short-circuit
```json
{
"$and": [
{"$ref": "/x"},
{"$gt": [{"$ref": "/y"}, 10]},
{"$eq": [{"$ref": "/status"}, "active"]}
]
}
```
- Processes values in order through value pipeline
- Returns last result if all are truthy
- Short-circuits and returns first falsy result
**Example:**
```python
# Check multiple conditions
spec = {
"/is_valid": {
"$and": [
{"$ref": "/user/name"}, # truthy if name exists
{"$gte": [{"$ref": "/user/age"}, 18]}, # age >= 18
{"$in": ["admin", {"$ref": "/user/roles"}]} # has admin role
]
}
}
```
#### `$or` — Logical OR with short-circuit
```json
{
"$or": [
{"$ref": "/x"},
{"$ref": "/y"},
{"$ref": "/z"}
]
}
```
- Processes values in order through value pipeline
- Returns first truthy result
- Returns last result if all are falsy
**Example:**
```python
# Provide fallback values
spec = {
"/display_name": {
"$or": [
{"$ref": "/user/preferred_name"},
{"$ref": "/user/full_name"},
{"$ref": "/user/email"},
"Unknown User"
]
}
}
```
#### `$not` — Logical negation
```json
{
"$not": {"$ref": "/disabled"}
}
```
- Processes value through value pipeline
- Returns logical negation of the result
**Example:**
```python
# Negate condition
spec = {
"/is_enabled": {
"$not": {"$ref": "/settings/disabled"}
}
}
```
#### Comparison Operators
J-Perm provides comparison operators that work with any values:
**`$gt` — Greater than**
```json
{"$gt": [10, 5]} → true
{"$gt": ["${/age}", 18]} → true if age > 18
```
**`$gte` — Greater than or equal**
```json
{"$gte": [10, 10]} → true
{"$gte": [{"$ref": "/count"}, 100]} → true if count >= 100
```
**`$lt` — Less than**
```json
{"$lt": [5, 10]} → true
{"$lt": ["${/price}", 50]} → true if price < 50
```
**`$lte` — Less than or equal**
```json
{"$lte": [10, 10]} → true
{"$lte": [{"$ref": "/temperature"}, 30]} → true if temperature <= 30
```
**`$eq` — Equal**
```json
{"$eq": [10, 10]} → true
{"$eq": ["${/status}", "active"]} → true if status == "active"
```
**`$ne` — Not equal**
```json
{"$ne": [10, 5]} → true
{"$ne": ["${/role}", "admin"]} → true if role != "admin"
```
**Usage in conditions:**
```python
spec = [
{"/age": 25},
{
"op": "if",
"cond": {"$gte": [{"$ref": "@:/age"}, 18]},
"then": [{"/is_adult": True}],
"else": [{"/is_adult": False}],
},
]
result = engine.apply(spec, source={}, dest={})
# → {"age": 25, "is_adult": True}
```
**Features:**
- All operators accept exactly 2 values in a list
- Values are processed through `process_value` (support templates, `$ref`, `$cast`, etc.)
- Can be nested and combined with logical operators
#### Membership and Existence Operators
**`$in` — Python-style membership test**
Works with strings (substring), lists (element), and dicts (key):
```json
{"$in": ["world", "hello world"]} → true (substring)
{"$in": [2, [1, 2, 3]]} → true (element in list)
{"$in": ["key", {"key": "val"}]} → true (key in dict)
```
**`$exists` — Check if a path resolves**
Returns `true` if the pointer can be resolved without error, `false` otherwise.
Supports all context prefixes (`@:`, `&:`, `!:`, `_:`, or plain `/`).
```json
{"$exists": "/user/name"} → true if source has user.name
{"$exists": "@:/result"} → true if dest has /result
{"$exists": "&:/param"} → true if arg named 'param' was passed to the function
```
**Example — conditional processing:**
```python
spec = {
"op": "if",
"cond": {"$exists": "/optional_field"},
"then": [{"/result": "${/optional_field}"}],
"else": [{"/result": "default"}],
}
```
**Example — template path:**
```python
{"/ok": {"$exists": "/user/${/field_name}"}}
```
#### Mathematical Operators
J-Perm provides mathematical operators with support for 1+ operands:
**`$add` — Addition**
```json
{"$add": [10]} → 10
{"$add": [10, 5]} → 15
{"$add": [1, 2, 3, 4]} → 10 (1 + 2 + 3 + 4)
```
**`$sub` — Subtraction**
```json
{"$sub": [10]} → 10
{"$sub": [10, 5]} → 5
{"$sub": [100, 20, 10]} → 70 ((100 - 20) - 10)
```
**`$mul` — Multiplication**
```json
{"$mul": [5]} → 5
{"$mul": [10, 5]} → 50
{"$mul": [2, 3, 4]} → 24 ((2 * 3) * 4)
```
**`$div` — Division**
```json
{"$div": [10]} → 10
{"$div": [10, 5]} → 2.0
{"$div": [100, 2, 5]} → 10.0 ((100 / 2) / 5)
```
**`$pow` — Exponentiation**
```json
{"$pow": [2]} → 2
{"$pow": [2, 3]} → 8
{"$pow": [2, 3, 2]} → 64 ((2 ** 3) ** 2)
```
**`$mod` — Modulo**
```json
{"$mod": [10]} → 10
{"$mod": [10, 3]} → 1
{"$mod": [100, 7, 3]} → 2 ((100 % 7) % 3)
```
**Nested expressions:**
```python
# Calculate: (price * quantity) + shipping
spec = {
"/total": {
"$add": [
{"$mul": [{"$ref": "/price"}, {"$ref": "/quantity"}]},
{"$ref": "/shipping"}
]
}
}
# Complex: ((10 + 5) * 2) - 3 = 27
spec = {
"/result": {
"$sub": [
{"$mul": [{"$add": [10, 5]}, 2]},
3
]
}
}
```
**Features:**
- Accept 1+ operands (1 operand: returns the value itself)
- 2+ operands: apply operation left-to-right
- Values are processed through `process_value` (support templates, `$ref`, `$cast`, etc.)
- Can be nested to create complex expressions
- Work seamlessly with comparison operators in conditions
---
### 4. String Operations
J-Perm provides comprehensive string manipulation constructs:
#### Split and Join
```python
# Split string by delimiter
{"$str_split": {"string": "a,b,c", "delimiter": ","}} → ["a", "b", "c"]
{"$str_split": {"string": "a:b:c", "delimiter": ":", "maxsplit": 1}} → ["a", "b:c"]
# Join array into string
{"$str_join": {"array": ["a", "b", "c"], "separator": "-"}} → "a-b-c"
{"$str_join": {"array": [1, 2, 3], "separator": ","}} → "1,2,3"
```
#### Slicing
```python
# Extract substring
{"$str_slice": {"string": "hello", "start": 1, "end": 4}} → "ell"
{"$str_slice": {"string": "hello", "start": 2}} → "llo"
{"$str_slice": {"string": "hello", "end": 3}} → "hel"
{"$str_slice": {"string": "hello", "start": -3}} → "llo"
```
**Note:** String slicing is also supported in JSON Pointer syntax:
```python
{"$ref": "/text[0:5]"} # first 5 characters
{"$ref": "/text[6:]"} # from 6th character to end
{"$ref": "/text[-5:]"} # last 5 characters
```
#### Case Conversion
```python
{"$str_upper": "hello"} → "HELLO"
{"$str_lower": "HELLO"} → "hello"
```
#### Trimming
```python
# Strip whitespace (default)
{"$str_strip": " hello "} → "hello"
{"$str_lstrip": " hello "} → "hello "
{"$str_rstrip": " hello "} → " hello"
# Strip specific characters
{"$str_strip": {"string": "***hello***", "chars": "*"}} → "hello"
{"$str_lstrip": {"string": "___hello", "chars": "_"}} → "hello"
{"$str_rstrip": {"string": "hello___", "chars": "_"}} → "hello"
```
#### Replace
```python
{"$str_replace": {"string": "hello", "old": "ll", "new": "rr"}} → "herro"
{"$str_replace": {"string": "aaa", "old": "a", "new": "b", "count": 2}} → "bba"
```
#### String Checks
```python
{"$str_contains": {"string": "hello world", "substring": "world"}} → true
{"$str_startswith": {"string": "hello", "prefix": "he"}} → true
{"$str_endswith": {"string": "hello", "suffix": "lo"}} → true
```
---
### 5. Regular Expressions
J-Perm supports powerful regex operations using Python's `re` module:
#### Match and Search
```python
# Check if entire string matches pattern
{"$regex_match": {"pattern": "^\\d+$", "string": "123"}} → true
{"$regex_match": {"pattern": "^\\d+$", "string": "abc"}} → false
# Find first occurrence
{"$regex_search": {"pattern": "\\d+", "string": "abc123def"}} → "123"
{"$regex_search": {"pattern": "\\d+", "string": "abc"}} → null
```
#### Find All Matches
```python
{"$regex_findall": {"pattern": "\\d+", "string": "a1b2c3"}} → ["1", "2", "3"]
{"$regex_findall": {"pattern": "\\d+", "string": "abc"}} → []
```
#### Replace with Regex
```python
# Simple replacement
{"$regex_replace": {"pattern": "\\d+", "replacement": "X", "string": "a1b2c3"}} → "aXbXcX"
# With backreferences
{"$regex_replace": {
"pattern": "(\\w+)@(\\w+)",
"replacement": "\\1 AT \\2",
"string": "user@domain"
}} → "user AT domain"
# Limited replacements
{"$regex_replace": {"pattern": "\\d+", "replacement": "X", "string": "a1b2c3", "count": 2}} → "aXbXc3"
```
#### Extract Capture Groups
```python
{"$regex_groups": {"pattern": "(\\w+)@(\\w+)", "string": "user@domain"}} → ["user", "domain"]
{"$regex_groups": {"pattern": "(\\d+)-(\\d+)", "string": "123-456"}} → ["123", "456"]
```
**Optional `flags` parameter:**
All regex constructs accept optional `flags` parameter (e.g., `re.IGNORECASE = 2`):
```python
{"$regex_match": {"pattern": "^hello$", "string": "HELLO", "flags": 2}} → true
```
---
### 6. Functions and Error Handling
J-Perm supports defining reusable functions and controlled error handling.
#### `$def` — Define a function
```json
{
"$def": "myFunction",
"params": ["arg1", "arg2"],
"body": [
{"/result": "${&:/arg1}"},
{"/total": "${int:${&:/arg2}}"}
],
"return": "/total",
"context": "copy",
"on_failure": [
{"/error": "Function failed"}
]
}
```
- `params` — list of parameter names (optional, default: `[]`)
- `body` — actions to execute when function is called
- `return` — path in local context to return (optional, default: entire dest); superseded by `$return` if used inside the body
- `context` — how the function's dest is initialized (see below)
- `on_failure` — error handler actions (optional)
**Accessing parameters:**
Inside the function body, parameters are available via the `&:` prefix:
```python
spec = [
{
"$def": "greet",
"params": ["name"],
"body": [{"/msg": "Hello, ${&:/name}!"}],
"return": "/msg",
},
{"/result": {"$func": "greet", "args": ["World"]}},
]
# → {"result": "Hello, World!"}
```
**Accessing original source:**
The original source document is always accessible via the plain `/` pointer (or `_:` alias):
```python
spec = [
{
"$def": "getConfig",
"body": [{"/cfg": {"$ref": "/config/key"}}],
"return": "/cfg",
},
{"/result": {"$func": "getConfig"}},
]
result = engine.apply(spec, source={"config": {"key": "production"}}, dest={})
# → {"result": "production"}
```
**`context` parameter — dest initialization mode:**
| Value | Behavior |
|-------|----------|
| `"copy"` (default) | Function body operates on a **deep copy** of the caller's `dest`. Mutations stay local. |
| `"new"` | Function body starts with an **empty** `dest = {}`. Cannot see the caller's dest. |
| `"shared"` | Function body operates on the **same** dest object as the caller. Mutations are visible to the caller. |
```python
# context: "copy" (default) — isolated
spec = [
{"$def": "f", "body": [{"/internal": 99}]},
{"/result": {"$func": "f"}},
]
# "internal" does NOT appear at the top level of the outer dest
# context: "new" — fresh slate
spec = [
{"/outer": "hello"},
{
"$def": "f",
"context": "new",
"body": [{"/saw_outer": {"$exists": "@:/outer"}}],
"return": "/saw_outer",
},
{"/result": {"$func": "f"}},
]
# → {"outer": "hello", "result": false} (function can't see /outer)
# context: "shared" — direct mutation
spec = [
{"$def": "f", "context": "shared", "body": [{"/shared_key": True}]},
{"$func": "f"},
]
# → {"shared_key": true} (mutation visible in outer dest)
```
#### `$func` — Call a func | text/markdown | null | Roman <kuschanow@gmail.com> | null | null | MIT | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"jmespath",
"regex"
] | [] | [] | [] | [
"Homepage, https://github.com/kuschanow/j-perm",
"Source, https://github.com/kuschanow/j-perm",
"Tracker, https://github.com/kuschanow/j-perm/issues",
"Documentation, https://github.com/kuschanow/j-perm"
] | twine/6.2.0 CPython/3.11.0 | 2026-02-20T14:06:30.481783 | j_perm-1.6.0.tar.gz | 109,987 | 67/02/3ad68936a8ac9cddee78fd8641d5273cf433e506087147eccf0dcedb19e6/j_perm-1.6.0.tar.gz | source | sdist | null | false | c1b7558cad0ef98605835e9e902d87c4 | 8fd6e268e4283d3adbc85d66bb8d1f3aafdcfc0d689c90435b1127a7f592903f | 67023ad68936a8ac9cddee78fd8641d5273cf433e506087147eccf0dcedb19e6 | null | [] | 234 |
2.4 | cmem-client | 0.9.0 | Next generation eccenca Corporate Memory client library. | <!-- markdownlint-disable MD012 MD013 MD024 MD033 -->
# cmem-client
Next generation eccenca Corporate Memory client library.
[![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier]
## Development
- Run [task](https://taskfile.dev/) to see all major development tasks.
- Use [pre-commit](https://pre-commit.com/) to avoid errors before commit.
- This repository was created with [this copier template](https://github.com/eccenca/cmem-plugin-template).
## Goals
Compared to [cmem-cmempy](https://pypi.org/project/cmem-cmempy/), this package was started to have the following advantages:
- Better logging:
- ?
- Validation of incoming data:
- This is done using [pydantic](https://github.com/pydantic/pydantic).
- See the `models` subdirectory for details.
- Availability of data objects and proper typing:
- In addition to pydantic models, we use [mypy](https://www.mypy-lang.org/) to complain about untyped code.
- Async capabilities:
- Switching from requests to [httpx](https://www.python-httpx.org/) allows for using asynchronous calls as well as HTTP/2 sessions, if needed.
- Documentation:
- [MkDocs](https://www.mkdocs.org/) together with [mkdocstrings](https://mkdocstrings.github.io/) build the foundation for nice developer documentation.
[poetry-link]: https://python-poetry.org/
[poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
[ruff-link]: https://docs.astral.sh/ruff/
[ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
[mypy-link]: https://mypy-lang.org/
[mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
[copier]: https://copier.readthedocs.io/
[copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json
| text/markdown | eccenca GmbH | cmempy-developer@eccenca.com | null | null | Apache-2.0 | eccenca Corporate Memory, client | [
"Development Status :: 4 - Beta",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | <4,>=3.13 | [] | [] | [] | [
"eccenca-marketplace-client<0.8.0,>=0.7.0",
"httpx<0.28.0,>=0.27.0",
"pydantic<3.0.0,>=2.8.2",
"pyjwt<3.0.0,>=2.8.0",
"rdflib<8.0.0,>=7.2.1",
"xdg-base-dirs<7.0.0,>=6.0.2"
] | [] | [] | [] | [] | poetry/2.3.1 CPython/3.12.12 Darwin/24.6.0 | 2026-02-20T14:06:04.827833 | cmem_client-0.9.0-py3-none-any.whl | 89,132 | 08/59/fbaa1b76c626e45169f44b578cc0f51eb67ac790ef80568ce735f14c4fd9/cmem_client-0.9.0-py3-none-any.whl | py3 | bdist_wheel | null | false | de527de46a777540f87059e26538f25e | ef7c621fd9b15d7c09c8b9326460855cf38d81490792c114d32ae501d3f3cdce | 0859fbaa1b76c626e45169f44b578cc0f51eb67ac790ef80568ce735f14c4fd9 | null | [
"LICENSE"
] | 215 |
2.3 | revox | 0.0.3 | The official Python library for the revox API | # Revox Python API library
<!-- prettier-ignore -->
[)](https://pypi.org/project/revox/)
The Revox Python library provides convenient access to the Revox 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 full API of this library can be found in [api.md](https://github.com/revoxai/revox-python/tree/main/api.md).
## Installation
```sh
# install from PyPI
pip install revox
```
## Usage
The full API of this library can be found in [api.md](https://github.com/revoxai/revox-python/tree/main/api.md).
```python
import os
from revox import Revox
client = Revox(
api_key=os.environ.get("REVOX_API_KEY"), # This is the default and can be omitted
)
assistant = client.assistants.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
print(assistant.assistant)
```
While you can provide an `api_key` keyword argument,
we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
to add `REVOX_API_KEY="My API Key"` to your `.env` file
so that your API Key is not stored in source control.
## Async usage
Simply import `AsyncRevox` instead of `Revox` and use `await` with each API call:
```python
import os
import asyncio
from revox import AsyncRevox
client = AsyncRevox(
api_key=os.environ.get("REVOX_API_KEY"), # This is the default and can be omitted
)
async def main() -> None:
assistant = await client.assistants.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
print(assistant.assistant)
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 revox[aiohttp]
```
Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
```python
import os
import asyncio
from revox import DefaultAioHttpClient
from revox import AsyncRevox
async def main() -> None:
async with AsyncRevox(
api_key=os.environ.get("REVOX_API_KEY"), # This is the default and can be omitted
http_client=DefaultAioHttpClient(),
) as client:
assistant = await client.assistants.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
print(assistant.assistant)
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 revox import Revox
client = Revox()
assistant = client.assistants.create(
name="name",
prompt="prompt",
calendly={
"connection_id": "connection_id",
"event_type_id": "event_type_id",
},
)
print(assistant.calendly)
```
## 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 `revox.APIConnectionError` is raised.
When the API returns a non-success status code (that is, 4xx or 5xx
response), a subclass of `revox.APIStatusError` is raised, containing `status_code` and `response` properties.
All errors inherit from `revox.APIError`.
```python
import revox
from revox import Revox
client = Revox()
try:
client.assistants.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
except revox.APIConnectionError as e:
print("The server could not be reached")
print(e.__cause__) # an underlying Exception, likely raised within httpx.
except revox.RateLimitError as e:
print("A 429 status code was received; we should back off a bit.")
except revox.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 revox import Revox
# Configure the default for all requests:
client = Revox(
# default is 2
max_retries=0,
)
# Or, configure per-request:
client.with_options(max_retries=5).assistants.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
```
### 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 revox import Revox
# Configure the default for all requests:
client = Revox(
# 20 seconds (default is 1 minute)
timeout=20.0,
)
# More granular control:
client = Revox(
timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)
# Override per-request:
client.with_options(timeout=5.0).assistants.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
```
On timeout, an `APITimeoutError` is thrown.
Note that requests that time out are [retried twice by default](https://github.com/revoxai/revox-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 `REVOX_LOG` to `info`.
```shell
$ export REVOX_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 revox import Revox
client = Revox()
response = client.assistants.with_raw_response.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
)
print(response.headers.get('X-My-Header'))
assistant = response.parse() # get the object that `assistants.create()` would have returned
print(assistant.assistant)
```
These methods return an [`APIResponse`](https://github.com/revoxai/revox-python/tree/main/src/revox/_response.py) object.
The async client returns an [`AsyncAPIResponse`](https://github.com/revoxai/revox-python/tree/main/src/revox/_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.assistants.with_streaming_response.create(
name="REPLACE_ME",
prompt="REPLACE_ME",
) 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 revox import Revox, DefaultHttpxClient
client = Revox(
# Or use the `REVOX_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 revox import Revox
with Revox() 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/revoxai/revox-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 revox
print(revox.__version__)
```
## Requirements
Python 3.9 or higher.
## Contributing
See [the contributing documentation](https://github.com/revoxai/revox-python/tree/main/./CONTRIBUTING.md).
| text/markdown | Revox | null | 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/revoxai/revox-python",
"Repository, https://github.com/revoxai/revox-python"
] | 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-20T14:06:01.256882 | revox-0.0.3.tar.gz | 232,988 | 2d/8b/eac9fded6e00806b8a92451d0ae5bfca5a17b1e4cd9b5105613e01df7853/revox-0.0.3.tar.gz | source | sdist | null | false | bcb9750c138a81a47ac607ec0035c7c9 | f257dc761a5f6f600fb315c67140215a1c45ee7b7bcdfd7f75b576a561d5b542 | 2d8beac9fded6e00806b8a92451d0ae5bfca5a17b1e4cd9b5105613e01df7853 | null | [] | 224 |
2.4 | mlarray | 0.0.49 | Array format specialized for Machine Learning with Blosc2 backend and standardized metadata. | <p align="center">
<img src="https://raw.githubusercontent.com/MIC-DKFZ/mlarray/main/assets/banner.png" alt="{ML Array} banner" width="700" />
</p>
<p align="center">
<a href="https://pypi.org/project/mlarray/"><img src="https://img.shields.io/pypi/v/mlarray?logo=pypi&color=brightgreen&cacheSeconds=300&v" alt="PyPI" align="middle" /></a>
<a href="https://pypi.org/project/mlarray/"><img src="https://img.shields.io/pypi/pyversions/mlarray?logo=python&cacheSeconds=300&v" alt="Python Version" align="middle" /></a>
<a href="https://github.com/MIC-DKFZ/mlarray/actions"><img src="https://img.shields.io/github/actions/workflow/status/MIC-DKFZ/mlarray/workflow.yml?branch=main&logo=github" alt="Tests" align="middle" /></a>
<a href="https://MIC-DKFZ.github.io/mlarray/"><img src="https://img.shields.io/badge/docs-mlarray-blue?logo=readthedocs&logoColor=white" alt="Docs" align="middle" /></a>
<a href="https://github.com/MIC-DKFZ/mlarray/blob/main/LICENSE"><img src="https://img.shields.io/github/license/MIC-DKFZ/mlarray" alt="License" align="middle" /></a>
</p>
**tl;dr:** Working with large medical or scientific images for machine learning? -> Use MLArray.
MLArray is a purpose-built file format for *N*-dimensional medical and scientific array data in machine learning workflows. It replaces the usual patchwork of source formats and late-stage conversions to NumPy/Zarr/Blosc2 by layering **standardized metadata** on top of a **Blosc2-backed** storage layout, so the same files work reliably across training, analysis, and visualization tools (including [Napari](https://napari.org) and [MITK](https://www.mitk.org/wiki/The_Medical_Imaging_Interaction_Toolkit_%28MITK%29)).
## Installation
You can install mlarray via [pip](https://pypi.org/project/mlarray/):
```bash
pip install mlarray
```
To enable the `mlarray_convert` CLI command, install MLArray with the necessary extra dependencies:
```bash
pip install mlarray[all]
```
## Documentaion
See the [documentation](https://MIC-DKFZ.github.io/mlarray/) for the [API reference](https://MIC-DKFZ.github.io/mlarray/api/), the [metadata schema](https://MIC-DKFZ.github.io/mlarray/schema/), [usage examples](https://MIC-DKFZ.github.io/mlarray/usage/) or [CLI usage](https://MIC-DKFZ.github.io/mlarray/cli/).
## Usage
Below are common usage patterns for loading, saving, and working with metadata.
### Default usage
```python
import numpy as np
from mlarray import MLArray
array = np.random.random((128, 256, 256))
image = MLArray(array) # Create MLArray image
image.save("sample.mla")
image = MLArray("sample.mla") # Loads image
```
### Memory-mapped usage
```python
from mlarray import MLArray
import numpy as np
# read-only, partial access (default)
image = MLArray.open("sample.mla", mmap_mode='r')
crop = image[10:20, 50:60] # Read crop
# read/write, partial access
image = MLArray.open("sample.mla", mmap_mode='r+')
image[10:20, 50:60] *= 5 # Modify crop in memory and disk
# read/write, partial access, create/overwrite
array = np.random.random((128, 256, 256))
image = MLArray.create("sample.mla", shape=array.shape, dtype=array.dtype, mmap_mode='w+')
image[...] = array # Modify image in memory and disk
```
### Metadata inspection and manipulation
```python
import numpy as np
from mlarray import MLArray
array = np.random.random((64, 128, 128))
image = MLArray(
array,
spacing=(1.0, 1.0, 1.5),
origin=(10.0, 10.0, 30.0),
direction=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
meta={"patient_id": "123", "modality": "CT"}, # Any metadata from the original image source (for example raw DICOM metadata)
)
print(image.spacing) # [1.0, 1.0, 1.5]
print(image.origin) # [10.0, 10.0, 30.0]
print(image.meta.source) # {"patient_id": "123", "modality": "CT"}
image.spacing[1] = 5.3
image.meta.source["study_id"] = "study-001"
image.save("with-metadata.mla")
# Open memory-mapped
image = MLArray.open("with-metadata.mla", mmap_mode='r+')
image.meta.source["study_id"] = "new-study" # Modify metadata
image.close() # Close and save metadata, only necessary to save modified metadata
```
### Copy metadata with overrides
```python
import numpy as np
from mlarray import MLArray
base = MLArray("sample.mla")
array = np.random.random(base.shape)
image = MLArray(
array,
spacing=(0.8, 0.8, 1.0),
copy=base, # Copies all non-explicitly set arguments from base
)
image.save("copied-metadata.mla")
```
### Standardized metadata usage
```python
import numpy as np
from mlarray import MLArray, Meta
array = np.random.random((64, 128, 128))
image = MLArray(
array,
meta=Meta(source={"patient_id": "123", "modality": "CT"}, is_seg=True), # Add metadata in a pre-defined format
)
print(image.meta.source) # {"patient_id": "123", "modality": "CT"}
print(image.meta.is_seg) # True
image.meta.source["study_id"] = "study-001"
image.meta.is_seg = False
image.save("with-metadata.mla")
```
### Patch size variants
Default patch size (192):
```python
from mlarray import MLArray
image = MLArray("sample.mla") # Existing file
image.save("default-patch.mla") # Keeps existing layout metadata
loaded = MLArray("sample.mla")
image = MLArray(loaded.to_numpy(), patch_size='default')
image.save("default-patch-relayout.mla") # Uses constructor patch_size='default' (192)
```
Custom isotropic patch size (512):
```python
from mlarray import MLArray
loaded = MLArray("sample.mla")
image = MLArray(loaded.to_numpy(), patch_size=512)
image.save("patch-512.mla")
```
Custom non-isotropic patch size:
```python
from mlarray import MLArray
loaded = MLArray("sample.mla")
image = MLArray(loaded.to_numpy(), patch_size=(128, 192, 256))
image.save("patch-non-iso.mla")
```
Manual chunk/block size:
```python
from mlarray import MLArray
loaded = MLArray("sample.mla")
image = MLArray(
loaded.to_numpy(),
patch_size=None,
chunk_size=(1, 128, 128),
block_size=(1, 32, 32),
)
image.save("manual-chunk-block.mla")
```
Let Blosc2 itself configure chunk/block size:
```python
from mlarray import MLArray
loaded = MLArray("sample.mla")
image = MLArray(loaded.to_numpy(), patch_size=None)
# If patch_size, chunk_size and block_size are all None, Blosc2 will auto-configure chunk and block size
image.save("blosc2-auto.mla")
```
## CLI
### mlarray_header
Print the metadata header from a `.mla` or `.b2nd` file.
```bash
mlarray_header sample.mla
```
### mlarray_convert
Convert a NIfTI or NRRD file to MLArray and copy metadata.
```bash
mlarray_convert sample.nii.gz output.mla
```
## Contributing
Contributions are welcome! Please open a pull request with clear changes and add tests when appropriate.
## Acknowledgments
<p align="left">
<img src="https://github.com/MIC-DKFZ/vidata/raw/main/imgs/Logos/HI_Logo.png" width="150">
<img src="https://github.com/MIC-DKFZ/vidata/raw/main/imgs/Logos/DKFZ_Logo.png" width="500">
</p>
This repository is developed and maintained by the Applied Computer Vision Lab (ACVL)
of [Helmholtz Imaging](https://www.helmholtz-imaging.de/) and the
[Division of Medical Image Computing](https://www.dkfz.de/en/medical-image-computing) at DKFZ.
| text/markdown | null | Karol Gotkowski <karol.gotkowski@dkfz.de> | null | null | MIT | copier, template, python | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Operating System :: OS Independent"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"blosc2>=3",
"numpy>=2",
"build>=1.0; extra == \"dev\"",
"pytest>=7.0; extra == \"dev\"",
"twine>=4.0; extra == \"dev\"",
"setuptools_scm[toml]>=8.0; extra == \"dev\"",
"mkdocs-material>=9.5; extra == \"docs\"",
"mkdocs-include-markdown-plugin>=6.0; extra == \"docs\"",
"mkdocstrings[python]>=0.25; extra == \"docs\"",
"pymdown-extensions>=10.0; extra == \"docs\"",
"medvol; extra == \"all\""
] | [] | [] | [] | [
"Homepage, https://github.com/MIC-DKFZ/mlarray",
"Source, https://github.com/MIC-DKFZ/mlarray",
"Issues, https://github.com/MIC-DKFZ/mlarray/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:05:50.499604 | mlarray-0.0.49.tar.gz | 1,090,871 | 31/6c/cd2aafa6925233f64e8a54e1cf134652999ba80545d9e9511af0f345b91a/mlarray-0.0.49.tar.gz | source | sdist | null | false | 612c3a16aa07e312207e3fec8b3c05be | 42c74f0ba4f9cdd6a26a8bbb674dd2999a96d244d582832be0db0e61ba4b8726 | 316ccd2aafa6925233f64e8a54e1cf134652999ba80545d9e9511af0f345b91a | null | [
"LICENSE"
] | 223 |
2.4 | seqnado | 1.0.4 | Pipelines for genomics analysis | <!-- Header and badges -->
# SeqNado
[](https://github.com/Milne-Group/SeqNado/actions/workflows/build_docs.yml)
[](https://pypi.org/project/seqnado)
[](https://pepy.tech/projects/seqnado)
[](https://anaconda.org/bioconda/seqnado)
[](https://anaconda.org/bioconda/seqnado)
[](https://github.com/Milne-Group/SeqNado/releases)
[](LICENSE)
<p align="center">
<img src="https://raw.githubusercontent.com/Milne-Group/SeqNado/main/containers/pipeline/seqnado.png" alt="SeqNado logo" />
</p>
*A Snakemake-based bioinformatics toolkit for analyzing sequencing data from ATAC-seq, ChIP-seq, CUT&Tag, RNA-seq, SNP analysis, Methylation, CRISPR screens, and Micro-Capture-C experiments.*
## Table of Contents
- [Key Features](#key-features)
- [Supported Assays](#supported-assays)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Documentation](#documentation)
- [License](#license)
---
Modular, reproducible, and container-ready pipelines powered by Snakemake that take you from raw data to publication-ready results.
## Key Features
- **Comprehensive Assay Support**: Single framework for multiple sequencing assays
- **GEO/SRA Integration**: Download and process public datasets directly from GEO/SRA repositories
- **Customizable Workflows**: Easily modify parameters, use different tools for peak calling, bigwig generation etc.
- **User-Friendly CLI**: Intuitive command-line interface that guides you through setup and execution
- **Multiomics Support**: Analyze and integrate data from multiple sequencing assays in a single workflow
- **Snakemake-Powered**: Modular workflows with automatic parallelization and resource management
- **Container-Ready**: Fully containerized pipelines using Apptainer/Singularity for reproducibility
- **HPC-Optimized**: Seamless integration with SLURM and local execution modes
- **Advanced Analysis**:
- Comprehensive QC with MultiQC reports
- Peak calling with MACS2, SEACR, HOMER, and LanceOtron
- Consensus peakset generation and quantification across samples
- Spike-in normalization for ChIP-seq, ATAC-seq, and RNA-seq
- Automated differential expression with DESeq2 for RNA-seq
- Genome browser style plots with `PlotNado`
- UCSC genome browser hub generation
- ML-ready dataset creation
- **Flexible Configuration**: Interactive CLI for setup, or scriptable non-interactive mode
- **Machine Learning Ready**: Tools for preparing datasets for ML applications
## Supported Assays
- **ATAC-seq** (`atac`) - Chromatin accessibility profiling with TSS enrichment and fragment analysis
- **ChIP-seq** (`chip`) - Protein-DNA interaction mapping with spike-in support
- **CUT&Tag** (`cat`) - Low-input epigenomic profiling optimized for sparse signals
- **RNA-seq** (`rna`) - Transcriptome analysis with automated DESeq2 differential expression
- **SNP Analysis** (`snp`) - Variant detection and genotyping workflows
- **Methylation** (`meth`) - Bisulfite/TAPS sequencing for DNA methylation analysis
- **CRISPR Screens** (`crispr`) - Guide-level quantification and screen statistics
- **Micro-Capture-C** (`mcc`) - Chromatin conformation capture analysis
- **Multiomics** - Run multiple assay types together in a single integrated workflow
→ [View detailed assay workflows](https://Milne-Group.github.io/SeqNado/pipeline/)
## Installation
### Via Mamba (Recommended)
Install from the Bioconda channel:
```bash
mamba create -n seqnado -c bioconda seqnado
mamba activate seqnado
```
### Via uv (Fast Alternative)
Install using [uv](https://docs.astral.sh/uv/), a fast Python package installer:
```bash
uv venv seqnado-env
source seqnado-env/bin/activate # On macOS/Linux; use 'seqnado-env\Scripts\activate' on Windows
uv pip install seqnado
```
### Via Pip
Alternatively, install using pip:
```bash
pip install seqnado
```
### Initialize SeqNado
After installation, initialize your SeqNado environment:
```bash
seqnado init
```
**What this does:**
- Sets up genome configuration templates in `~/.config/seqnado/`
- Configures Apptainer/Singularity containers (if available)
- Installs Snakemake execution profiles for local and cluster execution
→ [Learn more about initialization](https://Milne-Group.github.io/SeqNado/initialisation/)
## Quick Start
Complete workflow from installation to results in 5 steps:
### 1. Set Up Genome References
Before processing data, configure reference genomes for alignment:
```bash
# List available genomes
seqnado genomes list atac
# Build a custom genome
seqnado genomes build rna --fasta hg38.fasta --name hg38 --outdir /path/to/genomes
```
→ [Complete genome setup guide](https://Milne-Group.github.io/SeqNado/genomes/)
### 2. Create Project Configuration
Generate a configuration file and project directory for your experiment:
```bash
seqnado config atac
```
**Output:** A dated project directory with configuration file and FASTQ folder:
```
YYYY-MM-DD_ATAC_project/
├── config_atac.yaml # Edit this to customize analysis parameters
└── fastqs/ # Place your FASTQ files here
```
→ [Configuration options guide](https://Milne-Group.github.io/SeqNado/configuration/)
### 3. Add FASTQ Files
**Option A: Use Your Own Data**
Symlink your raw sequencing data into the project directory:
```bash
ln -s /path/to/fastq/*.fastq.gz YYYY-MM-DD_ATAC_project/fastqs/
```
**Option B: Download from GEO/SRA**
Download public datasets directly from GEO/SRA repositories:
```bash
# Download data using a metadata TSV file
seqnado download metadata.tsv -o YYYY-MM-DD_ATAC_project/fastqs/ -a atac --cores 4
```
→ [GEO/SRA download guide](https://Milne-Group.github.io/SeqNado/geo_download/)
**Note:** Use symbolic links to avoid duplicating large files.
### 4. Generate Sample Metadata
Create a metadata CSV that describes your experimental design:
```bash
seqnado design atac
```
**Output:** `metadata_atac.csv` — Edit this file to specify:
- Sample names and groupings
- Experimental conditions
- Control/treatment relationships
- DESeq2 comparisons (for RNA-seq)
→ [Design file specification](https://Milne-Group.github.io/SeqNado/design/)
### 5. Run the Pipeline
Execute the analysis workflow (choose one based on your environment):
```bash
# Local machine (uses all available cores)
seqnado pipeline atac --preset le
# HPC cluster with SLURM scheduler
seqnado pipeline atac --preset ss --queue short
# Multiomics mode (processes multiple assays together)
seqnado pipeline --preset ss # Detects all config files in current directory
```
→ [Pipeline execution details](https://Milne-Group.github.io/SeqNado/pipeline/) | [Output files explained](https://Milne-Group.github.io/SeqNado/outputs/)
### Common Pipeline Options
**Execution Presets:**
These presets configure Snakemake execution parameters for different environments. Our default presets are optimized for typical use cases on a SLURM based HPC cluster. These are saved in ~/.config/seqnado/ when you run `seqnado init` and can be customized as needed.
- `--preset le` - Local execution (default, recommended for workstations)
- `--preset lc` - Local execution using conda environments
- `--preset ss` - SLURM scheduler (for HPC clusters)
**Resource Management:**
- `--queue short` - Specify SLURM partition/queue name
This is only needed on HPC clusters and your cluster uses multiple partitions. The default queue can be set in the SLURM preset configuration file.
- `-s/--scale-resources 1.5` - Multiply memory/time requirements by 1.5×
This is useful on HPC clusters to ensure jobs have sufficient resources and reduce the likelihood of out-of-memory errors. Very useful when processing very deeply sequenced datasets and avoids needing to manually adjust resource requirements for each rule on the command line.
**Commands passed to snakemake:**
Any snakemake command line options will automatically be passed through when you run `seqnado pipeline`. This allows you to easily customize the execution of the workflow. For example, you can specify `--rerun-incomplete` to automatically rerun any failed or incomplete jobs, or `--keep-going` to continue running independent jobs even if some fail.
Very useful flags:
`--rerun-incomplete` - Automatically rerun any failed or incomplete jobs
`--keep-going` - Continue running independent jobs even if some fail
`--unlock` - Unlock the workflow if it becomes locked due to an error or interruption or the workflow was cancelled before completion. This allows you to fix the issue and then rerun the workflow without needing to manually delete the lock file.
**Debugging & Testing:**
- `-n` - Dry run to preview commands without executing
→ [All CLI options](https://Milne-Group.github.io/SeqNado/cli/) | [HPC cluster setup](https://Milne-Group.github.io/SeqNado/cluster_config/)
## Documentation
For comprehensive guides and API documentation, visit:
**📚 [SeqNado Documentation](https://Milne-Group.github.io/SeqNado/)**
### Key Topics
- [Installation Guide](https://Milne-Group.github.io/SeqNado/installation/)
- [Genome Setup](https://Milne-Group.github.io/SeqNado/genomes/)
- [Configuration](https://Milne-Group.github.io/SeqNado/configuration/)
- [Design Files](https://Milne-Group.github.io/SeqNado/design/)
- [Pipeline Details](https://Milne-Group.github.io/SeqNado/pipeline/)
- [Outputs](https://Milne-Group.github.io/SeqNado/outputs/)
- [CLI Reference](https://Milne-Group.github.io/SeqNado/cli/)
- [HPC Cluster Configuration](https://Milne-Group.github.io/SeqNado/cluster_config/)
## License
This project is licensed under [GPL3](LICENSE).
| text/markdown | null | Alastair Smith <alastair.smith@ndcls.ox.ac.uk>, Catherine Chahrour <catherine.chahrour@msdtc.ox.ac.uk> | null | null | GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 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 General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is 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. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
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.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
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 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. Use with the GNU Affero General Public License.
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 Affero 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 special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU 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 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 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 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 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 General Public License for more details.
You should have received a copy of the GNU 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 the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
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 GPL, see
<https://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.
| null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"click<=8.3.1",
"cookiecutter<=2.6.0",
"numpy<=2.1.0,>=1.24",
"pandas<=2.3.3,>=2.0",
"pandera<=0.29.0",
"pexpect<=4.9.0",
"pip",
"pulp<=3.3.0",
"pybtex",
"pydantic<=2.12.5",
"pyyaml<=6.0.3",
"rich<=14.3.2",
"seaborn<=0.13.2",
"snakemake-wrapper-utils<=0.8.0",
"snakemake<=9.14.5,>=9.12.0",
"tracknado<1.0.0,>=0.3.1",
"typer<=0.21.1",
"wget<=3.2",
"snakemake-executor-plugin-slurm<=2.0.3; extra == \"slurm\"",
"snakemake-executor-plugin-aws-batch; extra == \"aws\"",
"mkdocs>=1.6.1; extra == \"docs\"",
"mkdocs-material>=9.7.1; extra == \"docs\"",
"mkdocstrings>=1.0.0; extra == \"docs\"",
"mkdocstrings-python>=2.0.1; extra == \"docs\"",
"mkdocs-typer2>=0.1.6; extra == \"docs\"",
"mkdocs-gen-files>=0.6.0; extra == \"docs\"",
"mkdocs-jupyter>=0.25.1; extra == \"docs\"",
"mkdocs-autorefs>=1.4.3; extra == \"docs\"",
"mkdocs-literate-nav>=0.6.2; extra == \"docs\"",
"mkdocs-section-index>=0.3.10; extra == \"docs\"",
"pygments>=2.19.2; extra == \"docs\""
] | [] | [] | [] | [
"Homepage, https://Milne-Group.github.io/SeqNado"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:05:26.583718 | seqnado-1.0.4.tar.gz | 411,755 | 3b/8c/92d4ad0c7878195416d3e8f33b95fea35fb3e50a5258c3fc02fdf34b7bb9/seqnado-1.0.4.tar.gz | source | sdist | null | false | bae0627b1393f67004ee64130c413b41 | 92aea64d618e8504e9a7ba4826a6f2827523d452f9ac4696d518e5371df639d3 | 3b8c92d4ad0c7878195416d3e8f33b95fea35fb3e50a5258c3fc02fdf34b7bb9 | null | [
"LICENSE"
] | 229 |
2.4 | metrana | 0.0.3 | Inephany client library to use Metrana. | # Metrana Client Library
Metrana is a metrics tracking client for ML/RL training runs. It provides a simple three-function API to log metrics from training loops to the Metrana ingestion service, with asynchronous batching, configurable backpressure handling, and automatic retry on failure.
## Installation
```bash
pip install metrana
```
The `metrana-protobuf` dependency is pulled in automatically.
## Quick Start
```python
import metrana
metrana.init(
api_key="your-api-key",
workspace_name="my-workspace",
project_name="my-project",
run_name="run-001",
)
for step in range(1000):
loss, accuracy = train_step()
metrana.log("loss", loss)
metrana.log("accuracy", accuracy)
metrana.close()
```
The API key can also be provided via the `METRANA_API_KEY` environment variable, in which case `api_key` can be omitted from `init()`.
## API Reference
### `metrana.init()`
Initialises the logger. Must be called once before `log()` or `close()`.
```python
metrana.init(
api_key: str,
workspace_name: str,
project_name: str,
run_name: str,
experiment_name: str | None = None,
# Behavioural strategies (can also be set via environment variables)
resume_strategy: str | None = None, # "Never" | "Allow"
backpressure_strategy: str | None = None, # "DropNew" | "Block" | "Raise"
error_strategy: str | None = None, # "Silent" | "Warn" | "RaiseOnLog" | "RaiseOnClose"
close_strategy: str | None = None, # "Immediate" | "CompletePending" | "CompleteAll"
log_level: str | None = None, # "Trace" | "Debug" | "Info" | "Success" | "Warn" | "Error" | "Critical" | "Off"
# Advanced
num_dispatch_workers: int = 4,
ingestion_url: str | None = None, # Overrides the default API endpoint
)
```
### `metrana.log()`
Logs a single metric value. Thread-safe and non-blocking by default.
```python
metrana.log(
metric_name: str, # Name of the metric series
value: float | int, # Metric value
scale: str | None = None, # "ML_STEP" | "EPISODE" | "ENVIRONMENT_STEP" (default: "ML_STEP")
step: int | None = None, # Explicit step index; auto-increments per series if omitted
labels: dict[str, str] | None = None, # Additional series labels
timestamp: int | None = None, # Unix nanoseconds; defaults to now
)
```
### `metrana.close()`
Shuts down the logger. Behaviour depends on the configured `close_strategy`.
```python
metrana.close()
```
## Metric Scales
| Scale | Use when |
|---|---|
| `ML_STEP` | One entry per gradient update / training step (default) |
| `EPISODE` | One entry per RL episode |
| `ENVIRONMENT_STEP` | One entry per RL environment interaction |
Pass the scale name as a string or use `metrana.StandardMetricScale`:
```python
from metrana import StandardMetricScale
metrana.log("reward", reward, scale=StandardMetricScale.EPISODE)
```
## Strategies
### Backpressure strategy
Controls what happens when the internal event queue is full.
| Value | Behaviour |
|---|---|
| `DropNew` | Silently discard the incoming event (default) |
| `Block` | Block the calling thread until space is available |
| `Raise` | Raise `MetranaEventQueueFullError` |
### Error strategy
Controls how API errors are surfaced to the caller.
| Value | Behaviour |
|---|---|
| `Silent` | Ignore errors |
| `Warn` | Log a warning and continue (default) |
| `RaiseOnLog` | Raise on the next `log()` call if errors have occurred |
| `RaiseOnClose` | Raise on `close()` if errors have occurred |
### Resume strategy
Controls what happens when a run with the same name already exists.
| Value | Behaviour |
|---|---|
| `Allow` | Create a new run or resume an existing one (default) |
| `Never` | Always create a new run; raise if it already exists |
### Close strategy
Controls how pending events are handled on shutdown.
| Value | Behaviour |
|---|---|
| `Immediate` | Shut down immediately, discarding pending events |
| `CompletePending` | Complete API requests already in flight, but discard events still queued (default) |
| `CompleteAll` | Wait for all queued events including those not yet dispatched |
## Environment Variables
All strategies and several other settings can be configured without code changes:
| Variable | Default | Accepted values |
|---|---|---|
| `METRANA_API_KEY` | — | Your API key |
| `METRANA_BACKPRESSURE_STRATEGY` | `DropNew` | `DropNew`, `Block`, `Raise` |
| `METRANA_ERROR_MODES` | `Warn` | `Silent`, `Warn`, `RaiseOnLog`, `RaiseOnClose` |
| `METRANA_RESUME_STRATEGY` | `Allow` | `Allow`, `Never` |
| `METRANA_CLOSE_STRATEGY` | `CompletePending` | `Immediate`, `CompletePending`, `CompleteAll` |
| `METRANA_LOG_LEVEL` | `Success` | `Trace`, `Debug`, `Info`, `Success`, `Warn`, `Error`, `Critical`, `Off` |
| `METRANA_EVENT_QUEUE_MAX_SIZE` | unbounded | Integer (`0` = unbounded) |
| `METRANA_DISPATCH_QUEUE_MAX_SIZE` | unbounded | Integer (`0` = unbounded) |
| `METRANA_ERROR_QUEUE_MAX_SIZE` | unbounded | Integer (`0` = unbounded) |
| text/markdown | null | Inephany <info@inephany.com> | null | null | Apache 2.0 | metrana, mlops, rlops, ml, metrics | [
"Development Status :: 4 - Beta",
"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 | [] | [] | [] | [
"numpy<2.0.0,>=1.24.0",
"loguru<0.8.0,>=0.7.0",
"requests<3.0.0,>=2.28.0",
"pydantic<3.0.0,>=2.5.0",
"urllib3<3.0.0,>=2.0.0",
"PyYAML<7.0.0,>=6.0.0",
"aiohttp<4.0.0,>=3.0.0",
"metrana-protobuf<1.0.0,>=0.0.0",
"pytest<9.0.0,>=7.0.0; extra == \"dev\"",
"pytest-mock<4.0.0,>=3.10.0; extra == \"dev\"",
"bump-my-version==0.11.0; extra == \"dev\"",
"black==24.4.2; extra == \"dev\"",
"isort==5.9.3; extra == \"dev\"",
"flake8==7.1.0; extra == \"dev\"",
"pre-commit==4.0.1; extra == \"dev\"",
"mypy==1.13.0; extra == \"dev\"",
"types-PyYAML>=6.0.12; extra == \"dev\"",
"types-redis>=4.5.0; extra == \"dev\"",
"types-requests>=2.28.0; extra == \"dev\"",
"types-cachetools>=6.1.0; extra == \"dev\"",
"typeguard==4.3.0; extra == \"dev\"",
"pytest-asyncio<1.0.0,>=0.23.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-20T14:04:21.952099 | metrana-0.0.3.tar.gz | 30,175 | ac/43/c51c5599252e3cf22daea771bdd0bcb959602e39f648aa24b7be650a377b/metrana-0.0.3.tar.gz | source | sdist | null | false | 4ab9317c6b27160d5912fa4a9cd133e5 | 295985bc33604ac172392a7fa7f9b8e22b6ae879bb1655ee28f0f132f611961e | ac43c51c5599252e3cf22daea771bdd0bcb959602e39f648aa24b7be650a377b | null | [
"LICENSE"
] | 214 |
2.4 | optix-mcp-server-ravn | 1.0.14 | MCP server for source code analysis | # optix-mcp-server-ravn
MCP server for source code analysis.
## Installation
### Option 1: Quick Install with Wizard (Recommended)
The easiest way to install Optix MCP Server is using the installation wizard.
#### Prerequisites
- macOS 12+ or Ubuntu 20.04+
- curl (pre-installed on most systems)
#### One-Command Install
```bash
# Install uv if not already installed
curl -LsSf https://astral.sh/uv/install.sh | sh
# Run the installation wizard
uvx --from optix-mcp-server-ravn optix install
```
The wizard will guide you through:
1. Selecting AI agents to configure (Claude Code, Cursor, VS Code, Codex CLI, OpenCode)
2. Choosing installation scope (global or local/project)
3. Optional expert analysis setup (requires OpenAI API key)
4. Optional dashboard configuration
5. Optional Slack notifications setup (requires Slack Bot Token)
#### Wizard Options
| Flag | Description |
|------|-------------|
| `--agents <list>` | Comma-separated agents: claude,cursor,codex,vscode,opencode |
| `--scope <scope>` | Installation scope: global or local |
| `--expert` | Enable expert analysis feature |
| `--no-expert` | Disable expert analysis feature |
| `--quiet, -q` | Suppress non-essential output |
| `--verbose, -v` | Enable detailed output |
#### Examples
```bash
# Interactive mode (recommended for first-time users)
uvx --from optix-mcp-server-ravn optix install
# Non-interactive: Install for Claude Code only, global scope
uvx --from optix-mcp-server-ravn optix install --agents claude --scope global
# Enable expert analysis during installation
uvx --from optix-mcp-server-ravn optix install --expert
```
#### Verify Installation
```bash
# Check configuration status
uvx --from optix-mcp-server-ravn optix health
```
### Option 2: Development Setup
For contributors or those who need to modify the source code.
#### Prerequisites
- Python 3.10 or higher (3.13.11 recommended via pyenv)
- pip or uv package manager
- Git
#### Clone and Setup Environment
```bash
# Clone repository
git clone <repository-url>
cd optix-mcp-server-ravn
# Setup Python version (if using pyenv)
pyenv install 3.13.11
pyenv local 3.13.11
# Create virtual environment
python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
```
#### Install Dependencies
```bash
# Install package with dev dependencies
pip install -e ".[dev]"
# Or with uv (recommended)
uv pip install -e ".[dev]"
```
#### Configure Environment (Optional)
For features requiring API keys (like `security_audit` tool with LLM expert analysis):
```bash
# Copy the example environment file
cp .env.example .env
# Edit .env and add your OpenAI API key
# Example:
# OPENAI_API_KEY=sk-...
```
The server automatically loads variables from `.env` file using `python-dotenv`.
#### Start Server
```bash
# Start with default settings (stdio transport)
python server.py
# Start with custom settings via environment variables
export SERVER_NAME=my-server
export LOG_LEVEL=DEBUG
python server.py
```
#### Quick Verification (Development)
Run this to verify your development setup is correct:
```bash
# 1. Check Python
python --version
# 2. Check dependencies
python -c "from mcp.server.fastmcp import FastMCP; print('MCP OK')"
# 3. Check tools
python -c "import server; from tools import get_available_tools; print(get_available_tools())"
# 4. Run tests
pytest tests/ -v --tb=short
```
Expected output: All tests pass, `health_check` in available tools list.
## Environment Variables
### Server Configuration
| Variable | Default | Description |
|----------|---------|-------------|
| `SERVER_NAME` | optix-mcp-server | Server name for MCP |
| `OPTIX_LOG_LEVEL` | INFO | Logging level (DEBUG, INFO, WARN) |
| `LOG_LEVEL` | INFO | Fallback logging level if OPTIX_LOG_LEVEL not set |
| `TRANSPORT` | stdio | Transport type (stdio, sse, http) |
| `DISABLED_TOOLS` | (empty) | Comma-separated list of tools to disable |
### API Keys (Optional)
Required for specific features like LLM expert analysis in audit tools (`security_audit`, `devops_audit`, `a11y_audit`, `principal_audit`):
| Variable | Description |
|----------|-------------|
| `OPENAI_API_KEY` | OpenAI API key for GPT models |
### Expert Analysis Configuration
Optional settings for LLM-based expert validation of audit findings:
| Variable | Default | Description |
|----------|---------|-------------|
| `EXPERT_ANALYSIS_ENABLED` | false | Enable expert LLM analysis of audit findings |
| `EXPERT_ANALYSIS_TIMEOUT` | 30 | Timeout for expert analysis in seconds |
| `EXPERT_ANALYSIS_MAX_FINDINGS` | 50 | Maximum number of findings to analyze |
**Note**: Expert analysis requires `EXPERT_ANALYSIS_ENABLED=true` and a valid `OPENAI_API_KEY`. The expert analysis feature works with all audit tools (`security_audit`, `devops_audit`, `a11y_audit`, `principal_audit`) to provide LLM-validated assessments of findings, identify additional concerns, and prioritize remediation efforts.
**Configuration via `.env` file** (recommended):
1. Copy `.env.example` to `.env`
2. Add your API keys
3. The server automatically loads `.env` using `python-dotenv`
### Slack Notifications Configuration
Optional settings for automatically sending audit findings to Slack channels:
| Variable | Default | Description |
|----------|---------|-------------|
| `SLACK_ENABLED` | false | Enable automatic Slack notifications for audit findings |
| `SLACK_BOT_TOKEN` | (empty) | Slack Bot User OAuth Token (starts with `xoxb-`) |
| `SLACK_CHANNEL_ID` | (empty) | Target Slack channel ID (e.g., `C01ABCDEF23`) |
| `SLACK_SEVERITY_FILTER` | all | Comma-separated severity levels: critical,high,medium,low,info |
**Note**: Slack notifications require:
1. A Slack App created at https://api.slack.com/apps with `chat:write` and `chat:write.public` scopes
2. Bot installed to your workspace with token generated
3. Channel ID obtained from Slack (for private channels, bot must be invited)
When enabled, audit findings matching the severity filter are automatically sent to the configured Slack channel as formatted messages.
**📖 For detailed setup instructions, see [docs/SLACK_NOTIFICATIONS.md](./docs/SLACK_NOTIFICATIONS.md)**
## Logging Configuration
### Setting Log Level
Control logging verbosity via the `OPTIX_LOG_LEVEL` environment variable:
```bash
# In .env file or shell
export OPTIX_LOG_LEVEL=DEBUG # Most verbose - detailed execution info
export OPTIX_LOG_LEVEL=INFO # Default - summary info
export OPTIX_LOG_LEVEL=WARN # Warnings only
```
### Log Output
Logs are written to:
- **File**: `logs/optix.log` (for real-time monitoring)
- **Stderr**: Always enabled for immediate feedback
Log format:
```
2026-01-18 10:30:45 - INFO - [security_audit] Step 1 completed: 3 findings
```
### Real-Time Log Monitoring
Monitor logs in real-time while the server is running:
```bash
# All logs from all tools
./watch-logs.sh all
# Filter by specific tool
./watch-logs.sh security # security_audit only
./watch-logs.sh a11y # a11y_audit only
./watch-logs.sh devops # devops_audit only
./watch-logs.sh health # health_check only
```
## Development Workflow
### Running Tests
> **Note**: Ensure the virtual environment is activated before running tests.
> If you see `ModuleNotFoundError: No module named 'mcp'`, run `source .venv/bin/activate` first.
```bash
# Activate venv (if not already active)
source .venv/bin/activate # On Windows: .venv\Scripts\activate
# Full test suite
pytest tests/ -v
# Unit tests only (fast)
pytest tests/unit/ -v
# Integration tests only
pytest tests/integration/ -v
# Specific test file
pytest tests/unit/tools/test_health_check.py -v
```
### Adding a New Tool
Tools in optix-mcp-server-ravn are MCP-agnostic, meaning they can be tested independently without MCP context.
1. **Create tool directory**:
```
tools/
└── my_tool/
├── __init__.py
├── core.py # Business logic (no MCP imports)
└── spec.md # Documentation
```
2. **Implement in `core.py`** (no MCP imports):
```python
def my_tool_impl(param: str) -> dict:
"""Pure business logic."""
return {"result": param.upper()}
```
3. **Register in `server.py`**:
```python
from tools.my_tool.core import my_tool_impl
from tools import register_tool
@mcp.tool()
def my_tool(param: str) -> str:
return json.dumps(my_tool_impl(param))
register_tool("my_tool", impl=my_tool_impl, description="My tool description")
```
4. **Add unit test** in `tests/unit/tools/test_my_tool.py`:
```python
from tools.my_tool.core import my_tool_impl
def test_my_tool_impl():
result = my_tool_impl("hello")
assert result["result"] == "HELLO"
```
## Troubleshooting
### Server won't start
1. **Check Python version**: `python --version` (needs 3.10+)
2. **Verify dependencies**: `pip list | grep mcp`
3. **Check configuration**:
```bash
python -c "from config.defaults import ServerConfiguration; print(ServerConfiguration.from_env())"
```
### Tests failing
1. **Ensure dev dependencies installed**: `pip install -e ".[dev]"` or `uv pip install -e ".[dev]"`
2. **Check pytest version**: `pytest --version` (needs 7.0+)
3. **Run single test for details**: `pytest tests/unit/tools/test_health_check.py -v`
### Import errors
**ModuleNotFoundError: No module named 'mcp'**
- Virtual environment not activated. Run: `source .venv/bin/activate`
- Dependencies not installed. Run: `pip install -e ".[dev]"`
**Other import errors**
1. **Ensure package is installed in editable mode**: `pip install -e .`
2. **Check PYTHONPATH** includes project root
3. **Verify `__init__.py` files** exist in all packages
### Configuration errors
If you see "server_name must be alphanumeric with hyphens allowed":
- Ensure `SERVER_NAME` environment variable uses only letters, numbers, and hyphens
- Example valid names: `my-server`, `optix-mcp-server-ravn`, `server123`
## Project Structure
```
optix-mcp-server-ravn/
├── server.py # MCP server entry point
├── config/
│ └── defaults.py # Configuration classes
├── tools/
│ ├── __init__.py # Tool registry
│ ├── base.py # Tool Protocol interface
│ └── health_check/ # health_check tool
│ ├── __init__.py
│ ├── core.py # Business logic (MCP-agnostic)
│ └── spec.md # Tool specification
└── tests/
├── integration/ # Integration tests
│ ├── conftest.py # Test fixtures
│ └── test_server_startup.py
└── unit/ # Unit tests
└── tools/
├── test_health_check.py
└── test_registry.py
```
| text/markdown | optix-mcp-server contributors | null | null | null | MIT | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"mcp[cli]>=1.25.0",
"python-dotenv>=1.0.0",
"questionary>=2.0.0",
"rich>=13.0.0",
"tomli>=2.0.0; python_version < \"3.11\"",
"websockets>=12.0",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest>=7.0; extra == \"dev\"",
"openai>=1.0.0; extra == \"llm\"",
"openai>=1.0.0; extra == \"openai\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:04:18.983648 | optix_mcp_server_ravn-1.0.14.tar.gz | 432,964 | a0/e2/f4dbec9b1f4f2034b4537e0fcbdb699520a5781ca1a5a22fd9b8d23774ed/optix_mcp_server_ravn-1.0.14.tar.gz | source | sdist | null | false | 597fa403f995b097157d6ef93de34114 | 3bd53da67637f1f1b44d68e53abc55fe807cdb35183028e07a88ffc30cec84f1 | a0e2f4dbec9b1f4f2034b4537e0fcbdb699520a5781ca1a5a22fd9b8d23774ed | null | [] | 205 |
2.4 | supertokens-python | 0.31.0 | SuperTokens SDK for Python | 
# SuperTokens Python SDK
<a href="https://supertokens.com/discord">
<img src="https://img.shields.io/discord/603466164219281420.svg?logo=discord"
alt="chat on Discord"></a>
<a href="https://pypi.org/project/supertokens-python">
<img alt="Last 30 days downloads for supertokens-python" src="https://pepy.tech/badge/supertokens-python/month"/>
</a>
## About
This is a Python library that is used to interface between a python API process and the SuperTokens http service.
Learn more at https://supertokens.com
## Documentation
To see documentation, please click [here](https://supertokens.com/docs/community/introduction).
## Contributing
Please see the [CONTRIBUTING.md](https://github.com/supertokens/supertokens-python/blob/master/CONTRIBUTING.md) file for instructions.
## Contact us
For any queries, or support requests, please email us at team@supertokens.io, or join our [Discord](https://supertokens.com/discord) server.
## Authors
Created with :heart: by the folks at SuperTokens.io.
| text/markdown | SuperTokens | team@supertokens.com | null | null | Apache 2.0 | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Intended Audience :: Developers",
"Topic :: Internet :: WWW/HTTP :: Session",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | https://github.com/supertokens/supertokens-python | null | >=3.8 | [] | [] | [] | [
"Deprecated<1.3.0",
"PyJWT[crypto]<3.0.0,>=2.5.0",
"aiosmtplib<4.0.0,>=1.1.6",
"asgiref<4,>=3.4.1",
"httpx<1.0.0,>=0.15.0",
"packaging<26.0,>=25.0",
"phonenumbers<9",
"pkce<1.1.0",
"pycryptodome<3.21.0",
"pydantic<3.0.0,>=2.10.6",
"pyotp<3",
"python-dateutil<3",
"sniffio<2.0.0,>=1.1",
"tldextract<6.0.0",
"twilio<10",
"typing_extensions<5.0.0,>=4.1.1",
"fastapi; extra == \"fastapi\"",
"uvicorn; extra == \"fastapi\"",
"python-dotenv==1.0.1; extra == \"fastapi\"",
"flask-cors; extra == \"flask\"",
"flask; extra == \"flask\"",
"python-dotenv==1.0.1; extra == \"flask\"",
"django-cors-headers; extra == \"django\"",
"django>=3; extra == \"django\"",
"django-stubs; extra == \"django\"",
"uvicorn; extra == \"django\"",
"python-dotenv==1.0.1; extra == \"django\"",
"django-cors-headers==3.11.0; extra == \"django2x\"",
"django<3,>=2; extra == \"django2x\"",
"django-stubs==1.9.0; extra == \"django2x\"",
"gunicorn; extra == \"django2x\"",
"python-dotenv==1.0.1; extra == \"django2x\"",
"adrf; extra == \"drf\"",
"django-cors-headers; extra == \"drf\"",
"django>=4; extra == \"drf\"",
"django-stubs; extra == \"drf\"",
"djangorestframework; extra == \"drf\"",
"gunicorn; extra == \"drf\"",
"uvicorn; extra == \"drf\"",
"python-dotenv==1.0.1; extra == \"drf\"",
"tzdata; extra == \"drf\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.3 | 2026-02-20T14:04:04.396063 | supertokens_python-0.31.0.tar.gz | 483,084 | 6f/18/9eee2728fcc7c3cc9d32ef3382290709c772a1527b3811ff2a03c75abf2a/supertokens_python-0.31.0.tar.gz | source | sdist | null | false | 5b938385abd661a60edadac6347d0c01 | 059bba4c72a98eb5e89d88dc6f82182f8c5ad745942df1c72903498826c13b65 | 6f189eee2728fcc7c3cc9d32ef3382290709c772a1527b3811ff2a03c75abf2a | null | [
"LICENSE.md"
] | 434 |
2.4 | captain-arro | 0.1.3 | Animated SVG arrow generators for web interfaces | # Captain Arro ⬅⛵️➡
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
**Captain Arro** is a Python library for generating animated SVG arrows for web interfaces. Create beautiful, customizable arrow animations with just a few lines of code.
Yes, this package is totally vibe coded. It's useful anyhow!
## Features
- 🎯 **Four arrow types**: Moving flow, spotlight flow, bouncing spread, and spotlight spread
- 🎨 **Fully customizable**: Colors, sizes, speeds, directions, and animations
- 🔧 **Type-safe**: Full TypeScript-style type hints for better development experience
- 📦 **Zero dependencies**: Pure Python implementation
- 🌐 **Web-ready**: Generates clean SVG code for direct HTML embedding
## Installation
```bash
pip install captain-arro
```
## Quick Start
```python
from captain_arro import MovingFlowArrowGenerator
# Create a simple right-pointing arrow
generator = MovingFlowArrowGenerator()
svg_content = generator.generate_svg()
# Save to file
generator.save_to_file("my_arrow.svg")
```
## Arrow Types
### 1. Moving Flow Arrows
Arrows that move continuously in one direction with a flowing animation.
```python
from captain_arro import MovingFlowArrowGenerator
# Blue arrows moving right
generator = MovingFlowArrowGenerator(
direction="right",
stroke_width=8,
color="#3b82f6",
num_arrows=6,
width=150,
height=100,
speed_in_px_per_second=25,
animation="ease-in-out"
)
```
### 2. Spotlight Flow Arrows
Arrows with a moving spotlight effect that highlights different parts.
```python
from captain_arro import SpotlightFlowArrowGenerator
# Purple spotlight effect
generator = SpotlightFlowArrowGenerator(
direction="right",
color="#8b5cf6",
num_arrows=3,
width=180,
height=120,
speed_in_px_per_second=40.0,
spotlight_size=0.3,
dim_opacity=0.5
)
```
### 3. Bouncing Spread Arrows
Arrows that spread outward from center with a bouncing animation.
```python
from captain_arro import BouncingSpreadArrowGenerator
# Teal arrows spreading horizontally
generator = BouncingSpreadArrowGenerator(
direction="horizontal",
color="#14b8a6",
num_arrows=4,
width=250,
height=100,
speed_in_px_per_second=15.0,
animation="ease-in-out",
center_gap_ratio=0.3,
stroke_width=10
)
```
### 4. Spotlight Spread Arrows
Spread arrows with spotlight effects radiating from center.
```python
from captain_arro import SpotlightSpreadArrowGenerator
# Indigo spotlight spreading horizontally
generator = SpotlightSpreadArrowGenerator(
direction="horizontal",
color="#6366f1",
stroke_width=12,
num_arrows=8,
width=300,
height=100,
speed_in_px_per_second=100.0,
spotlight_size=0.25,
dim_opacity=0.5,
center_gap_ratio=0.3,
)
```
## Configuration Options
### Common Parameters
All generators support these base parameters:
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `color` | `str` | `"#2563eb"` | Arrow color (hex, rgb, named colors) |
| `stroke_width` | `int` | `10` | Line thickness (min: 2) |
| `width` | `int` | `100` | SVG width in pixels |
| `height` | `int` | `100` | SVG height in pixels |
| `speed` | `float` | `20.0` | Animation speed (pixels per second) |
| `num_arrows` | `int` | `4` | Number of arrows to display |
### Flow Arrow Parameters
| Parameter | Type | Options | Description |
|-----------|------|---------|-------------|
| `direction` | `FLOW_DIRECTIONS` | `"right"`, `"left"`, `"up"`, `"down"` | Arrow movement direction |
| `animation` | `ANIMATION_TYPES` | `"ease-in-out"`, `"linear"`, `"ease"`, etc. | Animation timing function |
### Spotlight Parameters
| Parameter | Type | Default | Description |
|-----------------------------------|------|---------|-------------------------------------------------------|
| `spotlight_size` | `float` | `0.3` | Size of spotlight effect (0.1-1.0) |
| `spotlight_path_extension_factor` | `float` | `1.0` | Factor by which the path of the spotlight is extended |
| `dim_opacity` | `float` | `0.2` | Opacity of dimmed areas (0.0-1.0) |
### Spread Arrow Parameters
| Parameter | Type | Options | Description |
|-----------|------|---------|-------------|
| `direction` | `SPREAD_DIRECTIONS` | `"horizontal"`, `"vertical"` | Spread orientation |
| `center_gap_ratio` | `float` | `0.2` | Gap size in center (0.1-0.4) |
## Advanced Usage
### Custom Animations
```python
from captain_arro import MovingFlowArrowGenerator
# Fast linear animation upward
generator = MovingFlowArrowGenerator(
direction="up",
speed_in_px_per_second=50.0,
animation="linear",
num_arrows=6
)
```
### Responsive Sizing
```python
# Large arrow for desktop
desktop_arrow = MovingFlowArrowGenerator(width=300, height=120)
# Small arrow for mobile
mobile_arrow = MovingFlowArrowGenerator(width=150, height=60)
```
### Color Theming
```python
# Dark theme
dark_arrow = SpotlightFlowArrowGenerator(
color="#ffffff",
dim_opacity=0.1
)
# Brand colors
brand_arrow = BouncingSpreadArrowGenerator(
color="#your-brand-color"
)
```
## HTML Integration
Embed generated SVGs directly in your HTML:
```html
<!-- Option 1: Inline SVG -->
<div class="arrow-container">
<!-- Paste SVG content here -->
</div>
<!-- Option 2: External file -->
<img src="path/to/arrow.svg" alt="Animated arrow" />
<!-- Option 3: CSS background -->
<div style="background-image: url('path/to/arrow.svg')"></div>
```
## Type Safety
Captain Arro includes full type annotations for excellent IDE support:
```python
from captain_arro import FLOW_DIRECTIONS, ANIMATION_TYPES
# TypeScript-style literal types
direction: FLOW_DIRECTIONS = "right" # ✅ Valid
direction: FLOW_DIRECTIONS = "invalid" # ❌ Type error
animation: ANIMATION_TYPES = "ease-in-out" # ✅ Valid
animation: ANIMATION_TYPES = "bounce" # ❌ Type error
```
## Examples
The `examples/` directory contains comprehensive usage examples:
```bash
# Generate all example SVGs
python examples/basic_usage.py
# View examples
ls examples/output/
```
See [`examples/README.md`](examples/README.md) for detailed descriptions of each example.
## Development
### Running Tests
```bash
# Install development dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Run with coverage
pytest --cov=captain_arro
```
### Code Quality
```bash
# Format code
black captain_arro tests examples
# Sort imports
isort captain_arro tests examples
# Type checking
mypy captain_arro
# Linting
flake8 captain_arro tests examples
```
## API Reference
### Base Classes
- `AnimatedArrowGeneratorBase` - Abstract base class for all generators
### Generator Classes
- `MovingFlowArrowGenerator` - Moving flow arrows
- `SpotlightFlowArrowGenerator` - Spotlight flow arrows
- `BouncingSpreadArrowGenerator` - Bouncing spread arrows
- `SpotlightSpreadArrowGenerator` - Spotlight spread arrows
### Type Definitions
- `ANIMATION_TYPES` - Valid animation timing functions
- `FLOW_DIRECTIONS` - Valid flow directions
- `SPREAD_DIRECTIONS` - Valid spread directions
## Browser Compatibility
Generated SVGs work in all modern browsers that support:
- SVG animations (`animateTransform`)
- CSS animations (`@keyframes`)
- Linear gradients
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Changelog
### v0.1.0
- Initial release
- Four arrow generator types
- Full type safety
- Comprehensive test suite
- Documentation and examples
---
Made with ❤️ and good vibes
| text/markdown | Helge Esch | null | Helge Esch | null | null | svg, animation, arrows, graphics, web, ui | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Multimedia :: Graphics",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Text Processing :: Markup :: HTML"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"pytest>=7.0; extra == \"dev\"",
"pytest-cov>=4.0; extra == \"dev\"",
"black>=23.0; extra == \"dev\"",
"isort>=5.0; extra == \"dev\"",
"mypy>=1.0; extra == \"dev\"",
"flake8>=6.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/helgeesch/captain-arro",
"Repository, https://github.com/helgeesch/captain-arro",
"Documentation, https://github.com/helgeesch/captain-arro#readme",
"Bug Tracker, https://github.com/helgeesch/captain-arro/issues"
] | twine/6.2.0 CPython/3.11.7 | 2026-02-20T14:03:21.747460 | captain_arro-0.1.3.tar.gz | 28,488 | 72/40/057868bd5fe7b9fe918814bb4c4eeb95e9c6977440f98823c11b55b3a537/captain_arro-0.1.3.tar.gz | source | sdist | null | false | d1051454ee51471a6e00b55b0108bcbb | 4d56da895190605e290d929f36a1402192d3c40994361f3bad3a6c1ba479d387 | 7240057868bd5fe7b9fe918814bb4c4eeb95e9c6977440f98823c11b55b3a537 | MIT | [
"LICENSE"
] | 212 |
2.4 | stackit-sfs | 0.3.0 | STACKIT File Storage (SFS) | # stackit.sfs
API used to create and manage NFS Shares.
This package is part of the STACKIT Python SDK. For additional information, please visit the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.
## Installation & Usage
### pip install
```sh
pip install stackit-sfs
```
Then import the package:
```python
import stackit.sfs
```
## Getting Started
[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK. | text/markdown | STACKIT Developer Tools | developer-tools@stackit.cloud | null | null | null | null | [
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | https://github.com/stackitcloud/stackit-sdk-python | null | <4.0,>=3.9 | [] | [] | [] | [
"stackit-core>=0.0.1a",
"requests>=2.32.3",
"pydantic>=2.9.2",
"python-dateutil>=2.9.0.post0"
] | [] | [] | [] | [
"Homepage, https://github.com/stackitcloud/stackit-sdk-python",
"Issues, https://github.com/stackitcloud/stackit-sdk-python/issues"
] | poetry/2.2.1 CPython/3.9.25 Linux/6.11.0-1018-azure | 2026-02-20T14:03:15.105919 | stackit_sfs-0.3.0.tar.gz | 34,666 | af/49/a3905e956c533ecbd04ef463bb6a39f3848b8ae7cceff88d68d7355a2998/stackit_sfs-0.3.0.tar.gz | source | sdist | null | false | ccdcfeef2d9c5cec81ecf033558edc4e | d3c424c6704ca8b7ca650f5846443c5e39e331c6f44b7bcc226f194f892decb3 | af49a3905e956c533ecbd04ef463bb6a39f3848b8ae7cceff88d68d7355a2998 | null | [] | 209 |
2.4 | sd-webui-all-in-one | 2.0.29 | 支持部署和管理多种 WebUI 的工具 | <div align="center">
# SD WebUI All In One
_✨快速部署，简单易用_
<p align="center">
<a href="https://github.com/licyk/ani2xcur-cli/stargazers" style="margin: 2px;">
<img src="https://img.shields.io/github/stars/licyk/sd-webui-all-in-one?style=flat&logo=github&logoColor=silver&color=bluegreen&labelColor=grey" alt="Stars">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/issues">
<img src="https://img.shields.io/github/issues/licyk/sd-webui-all-in-one?style=flat&logo=github&logoColor=silver&color=bluegreen&labelColor=grey" alt="Issues">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/commits/dev">
<img src="https://flat.badgen.net/github/last-commit/licyk/sd-webui-all-in-one/dev?icon=github&color=green&label=last%20dev%20commit" alt="Commit">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/sync_repo.yml">
<img src="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/sync_repo.yml/badge.svg" alt="Sync">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/pwsh-lint.yml">
<img src="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/pwsh-lint.yml/badge.svg" alt="Lint">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/check_version.yaml">
<img src="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/check_version.yaml/badge.svg" alt="Check Installer Version">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/release.yml">
<img src="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/release.yml/badge.svg" alt="Release">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/pypi-release.yml">
<img src="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/pypi-release.yml/badge.svg" alt="PyPI Release">
</a>
<a href="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/py-lint.yml">
<img src="https://github.com/licyk/sd-webui-all-in-one/actions/workflows/py-lint.yml/badge.svg" alt="Ruff Lint">
</a>
</p>
</div>
- [SD WebUI All In One](#sd-webui-all-in-one)
- [SD WebUI All In One CLI](#sd-webui-all-in-one-cli)
- [SD WebUI All In One Notebook](#sd-webui-all-in-one-notebook)
- [SD Scripts Kaggle Jupyter NoteBook](#sd-scripts-kaggle-jupyter-notebook)
- [SD Trainer Scripts Kaggle Jupyter NoteBook](#sd-trainer-scripts-kaggle-jupyter-notebook)
- [SD Scripts Colab Jupyter NoteBook](#sd-scripts-colab-jupyter-notebook)
- [SD Trainer Colab Jupyter NoteBook](#sd-trainer-colab-jupyter-notebook)
- [HDM Train Kaggle Jupyter NoteBook](#hdm-train-kaggle-jupyter-notebook)
- [Stable Diffusion WebUI Colab NoteBook](#stable-diffusion-webui-colab-notebook)
- [ComfyUI Colab NoteBook](#comfyui-colab-notebook)
- [InvokeAI Colab NoteBook](#invokeai-colab-notebook)
- [Fooocus Colab Jupyter NoteBook](#fooocus-colab-jupyter-notebook)
- [Qwen TTS WebUI Colab Jupyter NoteBook](#qwen-tts-webui-colab-jupyter-notebook)
- [SD WebUI All In One Jupyter NoteBook](#sd-webui-all-in-one-jupyter-notebook)
- [SD WebUI All In One Colab Jupyter NoteBook](#sd-webui-all-in-one-colab-jupyter-notebook)
- [Fooocus kaggle Jupyter NoteBook](#fooocus-kaggle-jupyter-notebook)
- [SD Trainer Kaggle Jupyter NoteBook](#sd-trainer-kaggle-jupyter-notebook)
- [Installer](#installer)
- [SD WebUI Installer](#sd-webui-installer)
- [ComfyUI Installer](#comfyui-installer)
- [InvokeAI Installer](#invokeai-installer)
- [Fooocus Installer](#fooocus-installer)
- [SD-Trainer Installer](#sd-trainer-installer)
- [SD-Trainer-Script Installer](#sd-trainer-script-installer)
- [Qwen TTS WebUI Installer](#qwen-tts-webui-installer)
- [Python Installer](#python-installer)
- [Installer 自动化构建状态](#installer-自动化构建状态)
***
# SD WebUI All In One CLI
支持多平台安装和管理 WebUI 的 CLI 工具，支持部署的 WebUI 如下：
- [Stable-Diffusion-WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
- [Stable-Diffusion-WebUI-Forge](https://github.com/lllyasviel/stable-diffusion-webui-forge)
- [Stable-Diffusion-WebUI-reForge](https://github.com/Panchovix/stable-diffusion-webui-reForge)
- [Stable-Diffusion-WebUI-Forge-Classic](https://github.com/Haoming02/sd-webui-forge-classic)
- [Stable-Diffusion-WebUI-AMDGPU](https://github.com/lshqqytiger/stable-diffusion-webui-amdgpu)
- [SD.Next](https://github.com/vladmandic/automatic)
- [ComfyUI](https://github.com/Comfy-Org/ComfyUI)
- [InvokeAI](https://github.com/invoke-ai/InvokeAI)
- [Fooocus](https://github.com/lllyasviel/Fooocus)
- [SD-Trainer](https://github.com/Akegarasu/lora-scripts)
- [Kohya GUI](https://github.com/bmaltais/kohya_ss)
- [sd-scripts](https://github.com/kohya-ss/sd-scripts)
- [ai-toolkit](https://github.com/ostris/ai-toolkit)
- [finetrainers](https://github.com/a-r-r-o-w/finetrainers)
- [diffusion-pipe](https://github.com/tdrussell/diffusion-pipe)
- [musubi-tuner](https://github.com/kohya-ss/musubi-tuner)
- [Qwen TTS WebUI](https://github.com/licyk/qwen-tts-webui)
详细的说明[点击此处](docs/cli.md)阅读。
# SD WebUI All In One Notebook
支持部署不同 WebUI 的各种 Notebook，基于 [SD WebUI All In One](https://github.com/licyk/sd-webui-all-in-one/tree/main/sd_webui_all_in_one) 内核，支持部署的 WebUI 如下：
- [Stable-Diffusion-WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
- [Stable-Diffusion-WebUI-Forge](https://github.com/lllyasviel/stable-diffusion-webui-forge)
- [Stable-Diffusion-WebUI-reForge](https://github.com/Panchovix/stable-diffusion-webui-reForge)
- [Stable-Diffusion-WebUI-Forge-Classic](https://github.com/Haoming02/sd-webui-forge-classic)
- [Stable-Diffusion-WebUI-AMDGPU](https://github.com/lshqqytiger/stable-diffusion-webui-amdgpu)
- [SD.Next](https://github.com/vladmandic/automatic)
- [ComfyUI](https://github.com/Comfy-Org/ComfyUI)
- [InvokeAI](https://github.com/invoke-ai/InvokeAI)
- [Fooocus](https://github.com/lllyasviel/Fooocus)
- [SD-Trainer](https://github.com/Akegarasu/lora-scripts)
- [Kohya GUI](https://github.com/bmaltais/kohya_ss)
- [sd-scripts](https://github.com/kohya-ss/sd-scripts)
- [ai-toolkit](https://github.com/ostris/ai-toolkit)
- [finetrainers](https://github.com/a-r-r-o-w/finetrainers)
- [diffusion-pipe](https://github.com/tdrussell/diffusion-pipe)
- [musubi-tuner](https://github.com/kohya-ss/musubi-tuner)
- [Qwen TTS WebUI](https://github.com/licyk/qwen-tts-webui)
详细使用方法可查看 Notebook 中的说明，使用时请按顺序执行 Jupyter Notebook 单元。
>[!NOTE]
>点击蓝色名称可下载对应的 Jupyter NoteBook。
## SD Scripts Kaggle Jupyter NoteBook
[sd_scripts_kaggle.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_scripts_kaggle.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/sd_scripts_kaggle.ipynb))：适用于 Kaggle 部署 [sd-scripts](https://github.com/kohya-ss/sd-scripts)，可用于不同种类的模型训练，使用前需熟悉 sd-scripts 的使用方法。
>[!IMPORTANT]
>使用方法可阅读：
>[使用 HuggingFace / ModelScope 保存和下载文件 - licyk的小窝](https://licyk.netlify.app/2025/01/16/use-huggingface-or-modelscope-to-save-file/)
>[使用 Kaggle 进行模型训练 - licyk的小窝](https://licyk.netlify.app/2025/01/16/use-kaggle-to-training-sd-model)
>[!Caution]
>Kaggle 不允许上传 NSFW 的内容，尝试上传包含 NSFW 图片的训练集将导致 Kaggle 账号被封禁！
## SD Trainer Scripts Kaggle Jupyter NoteBook
[sd_trainer_scripts_kaggle.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_trainer_scripts_kaggle.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/sd_trainer_scripts_kaggle.ipynb))：适用于 Kaggle 部署 [sd-scripts](https://github.com/kohya-ss/sd-scripts) / [ai-toolkit](https://github.com/ostris/ai-toolkit) / [finetrainers](https://github.com/a-r-r-o-w/finetrainers) / [diffusion-pipe](https://github.com/tdrussell/diffusion-pipe) / [musubi-tuner](https://github.com/kohya-ss/musubi-tuner)，可用于不同种类的模型训练。
>[!IMPORTANT]
>1. 使用方法可参考：
>[使用 HuggingFace / ModelScope 保存和下载文件 - licyk的小窝](https://licyk.netlify.app/2025/01/16/use-huggingface-or-modelscope-to-save-file/)
>[使用 Kaggle 进行模型训练 - licyk的小窝](https://licyk.netlify.app/2025/01/16/use-kaggle-to-training-sd-model)
>2. 该 NoteBook 相对于 [SD Scripts Kaggle Jupyter NoteBook](#sd-scripts-kaggle-jupyter-notebook)，在配置环境部分有点区别，并且使用的命令也有些改变，如果需要旧版可使用 [SD Scripts Kaggle Jupyter NoteBook](#sd-scripts-kaggle-jupyter-notebook)。
>[!Caution]
>Kaggle 不允许上传 NSFW 的内容，尝试上传包含 NSFW 图片的训练集将导致 Kaggle 账号被封禁！
## SD Scripts Colab Jupyter NoteBook
[sd_scripts_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_scripts_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/sd_scripts_colab.ipynb))：适用于 Colab 部署 [sd-scripts](https://github.com/kohya-ss/sd-scripts)，**自己写来玩的，还有用来开发和测试管理核心**，要用的话就参考 [SD Scripts Kaggle Jupyter NoteBook](#sd-scripts-kaggle-jupyter-notebook)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/sd_scripts_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
## SD Trainer Colab Jupyter NoteBook
[sd_trainer_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_trainer_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/sd_trainer_colab.ipynb))：适用于 Colab 一键部署 [SD-Trainer](https://github.com/Akegarasu/lora-scripts) / [Kohya GUI](https://github.com/bmaltais/kohya_ss)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/sd_trainer_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
## HDM Train Kaggle Jupyter NoteBook
[hdm_train_kaggle.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/hdm_train_kaggle.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/hdm_train_kaggle.ipynb))：适用于 Kaggle / Colab 部署 [HDM](https://github.com/KohakuBlueleaf/HDM)，**写来玩的脚本，可能有 BUG**，要用的话就参考 [SD Scripts Kaggle Jupyter NoteBook](#sd-scripts-kaggle-jupyter-notebook)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/hdm_train_kaggle.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
>[!Caution]
>Kaggle 不允许上传 NSFW 的内容，尝试上传包含 NSFW 图片的训练集将导致 Kaggle 账号被封禁！
## Stable Diffusion WebUI Colab NoteBook
[stable_diffusion_webui_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/stable_diffusion_webui_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/stable_diffusion_webui_colab.ipynb))：适用于 Colab 一键部署 [Stable-Diffusion-WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) / [Stable-Diffusion-WebUI-Forge](https://github.com/lllyasviel/stable-diffusion-webui-forge) / [Stable-Diffusion-WebUI-reForge](https://github.com/Panchovix/stable-diffusion-webui-reForge) / [Stable-Diffusion-WebUI-Forge-Classic](https://github.com/Haoming02/sd-webui-forge-classic) / [Stable-Diffusion-WebUI-AMDGPU](https://github.com/lshqqytiger/stable-diffusion-webui-amdgpu) / [SD.Next](https://github.com/vladmandic/automatic)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/stable_diffusion_webui_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
## ComfyUI Colab NoteBook
[comfyui_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/comfyui_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/comfyui_colab.ipynb))：适用于 Colab 一键部署 [ComfyUI](https://github.com/Comfy-Org/ComfyUI)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/comfyui_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
## InvokeAI Colab NoteBook
[invokeai_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/invokeai_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/invokeai_colab.ipynb))：适用于 Colab 一键部署 [InvokeAI](https://github.com/invoke-ai/InvokeAI)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/invokeai_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
## Fooocus Colab Jupyter NoteBook
[fooocus_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/fooocus_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/fooocus_colab.ipynb))：适用于 Colab 一键部署 [Fooocus](https://github.com/lllyasviel/Fooocus)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/fooocus_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
## Qwen TTS WebUI Colab Jupyter NoteBook
[qwen_tts_webui_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/qwen_tts_webui_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/qwen_tts_webui_colab.ipynb))：适用于 Colab 一键部署 [Qwen TTS WebUI](https://github.com/licyk/qwen-tts-webui)。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/qwen_tts_webui_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
***
## SD WebUI All In One Jupyter NoteBook
[sd_webui_all_in_one.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_webui_all_in_one.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/sd_webui_all_in_one.ipynb))：支持部署多种 WebUI 的 Jupyter Notebook。
- 主要功能
1. 功能初始化：导入 SD WebUI All In One 所使用的功能
2. 参数配置：配置安装参数和远程访问方式
3. 应用参数配置：应用已设置的参数
4. 安装：根据配置安装对应的 WebUI
5. 启动：根据配置启动对应的 WebUI
- 其他功能
1. 自定义模型 / 扩展下载配置：设置要下载的模型 / 扩展参数
2. 自定义模型 / 扩展下载：根据配置进行下载模型 / 扩展
3. 更新：将已安装的 WebUI 进行更新
- 提示
1. 在参数配置界面，请填写工作区路径，选择要使用的 WebUI，根据自己的需求选择内网穿透方式（用于访问 WebUI 界面），再根据自己的需求选择模型和扩展。
2. 已知 CloudFlare、Gradio 内网穿透会导致 [Kaggle](https://www.kaggle.com) 平台强制关机，在使用 [Kaggle](https://www.kaggle.com) 平台时请勿勾选这两个选项。
3. 若使用 [Colab](https://colab.research.google.com) 平台，请注意该 Jupyter Notebook 无法在免费版的 Colab 账号中使用，运行前将会收到 Colab 的警告提示，强行运行将会导致 Colab 强制关机（如果 Colab 账号已付费订阅可直接使用该 Jupyter Notebook），可选择仓库中其他的 Jupyter Notebook（将 Colab 中禁止的 WebUI 移除了）。
4. [Ngrok](https://ngrok.com) 内网穿透的稳定性高，使用前需要填写 Ngrok Token，可在 [Ngrok](https://ngrok.com) 官网获取。
5. 在启动时将启动内网穿透，可在控制台输出中看到内网穿透地址，用于访问 WebUI 界面。
>[!WARNING]
>已停止维护，可能存在的 BUG 将不再修复。
## SD WebUI All In One Colab Jupyter NoteBook
[sd_webui_all_in_one_colab.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_webui_all_in_one_colab.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/sd_webui_all_in_one_colab.ipynb))：支持部署多种 WebUI 的 Jupyter Notebook，但移除了 Colab 免费版中会导致警告的 WebUI，适用于 Colab 免费用户。
Colab 链接：<a href="https://colab.research.google.com/github/licyk/sd-webui-all-in-one/blob/main/notebook/sd_webui_all_in_one_colab.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
>[!WARNING]
>已停止维护，可能存在的 BUG 将不再修复。
## Fooocus kaggle Jupyter NoteBook
[fooocus_kaggle.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/fooocus_kaggle.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/fooocus_kaggle.ipynb))：适用于 Kaggle 部署 [Fooocus](https://github.com/lllyasviel/Fooocus)。
>[!WARNING]
>已停止维护，可能存在的 BUG 将不再修复。
## SD Trainer Kaggle Jupyter NoteBook
[sd_trainer_kaggle.ipynb](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/sd_trainer_kaggle.ipynb)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/notebook/sd_trainer_kaggle.ipynb))：适用于 Kaggle 部署 [SD Trainer](https://github.com/Akegarasu/lora-scripts)，解决 Kaggle 环境问题导致无法运行 SD Trainer 的问题。
>[!WARNING]
>已停止维护，可能存在的 BUG 将不再修复。
***
# Installer
适用于 Windows / Linux / MacOS 平台部署 AI 的工具，无需提前安装任何环境（[Git](https://git-scm.com) / [Python](https://www.python.org/)），只需一键运行即可部署。不仅仅是部署工具，还是管理工具，实现环境的启动和维护。
>[!IMPORTANT]
>1. Installer 并不会使用系统中安装的 Git / Python，这是为了保证环境的独立性和可迁移性。并且因为环境的独立性和可迁移性，Installer 也可用做整合包制作器。
>2. 基于 Installer 的构建模式，可实现整合包制作全自动化，由 Installer 自动构建的整合包可在此列表查看：[AI 绘画 / 训练整合包列表](https://licyk.github.io/t/sd_portable)
>3. 由 Installer 制作的整合包说明可阅读：[AI 绘画 / 训练整合包 · licyk/sd-webui-all-in-one · Discussion #1](https://github.com/licyk/sd-webui-all-in-one/discussions/1)
[configure_env.bat](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/configure_env.bat)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/installer/configure_env.bat))：（仅适用 Windows 平台）配置 Installer 运行环境的一键配置脚本，首次使用 Installer 时需要运行一次该脚本。
## SD WebUI Installer
Windows / Linux / MacOS 平台一键部署 [Stable-Diffusion-WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) / [Stable-Diffusion-WebUI-Forge](https://github.com/lllyasviel/stable-diffusion-webui-forge) / [Stable-Diffusion-WebUI-reForge](https://github.com/Panchovix/stable-diffusion-webui-reForge) / [Stable-Diffusion-WebUI-Forge-Classic](https://github.com/Haoming02/sd-webui-forge-classic) / [Stable-Diffusion-WebUI-AMDGPU](https://github.com/lshqqytiger/stable-diffusion-webui-amdgpu) / [SD.Next](https://github.com/vladmandic/automatic) 的脚本，包含启动，管理 Stable Diffusion WebUI 的工具。
详细的说明[点击此处](docs/stable_diffusion_webui_installer.md)阅读。
## ComfyUI Installer
Windows / Linux / MacOS 平台一键部署 [ComfyUI](https://github.com/Comfy-Org/ComfyUI) 的脚本，包含启动，管理 ComfyUI 的工具。
详细的说明[点击此处](docs/comfyui_installer.md)阅读。
## InvokeAI Installer
Windows / Linux / MacOS 平台一键部署 [InvokeAI](https://github.com/invoke-ai/InvokeAI) 的脚本，包含启动，管理 InvokeAI 的工具。
详细的说明[点击此处](docs/invokeai_installer.md)阅读。
## Fooocus Installer
Windows / Linux / MacOS 平台一键部署 [Fooocus](https://github.com/lllyasviel/Fooocus) / [Fooocus-MRE](https://github.com/MoonRide303/Fooocus-MRE) / [RuinedFooocus](https://github.com/runew0lf/RuinedFooocus) 的脚本，包含启动，管理 Fooocus 的工具。
详细的说明[点击此处](docs/fooocus_installer.md)阅读。
## SD-Trainer Installer
Windows / Linux / MacOS 平台一键部署 [SD-Trainer](https://github.com/Akegarasu/lora-scripts) / [Kohya GUI](https://github.com/bmaltais/kohya_ss) 的脚本，包含启动，管理 SD-Trainer 的工具。
详细的说明[点击此处](docs/sd_trainer_installer.md)阅读。
## SD-Trainer-Script Installer
>[!WARNING]
>此部署工具部署的训练工具需要一定的编写训练命令基础，如果需要使用简单的模型训练工具，请使用 [SD-Trainer Installer](docs/sd_trainer_installer.md) 部署训练工具并使用。
Windows / Linux / MacOS 平台一键部署 [sd-scripts](https://github.com/kohya-ss/sd-scripts) / [ai-toolkit](https://github.com/ostris/ai-toolkit) / [finetrainers](https://github.com/a-r-r-o-w/finetrainers) / [diffusion-pipe](https://github.com/tdrussell/diffusion-pipe) / [musubi-tuner](https://github.com/kohya-ss/musubi-tuner) 的脚本，包含启动，管理 SD-Trainer-Script 的工具。
详细的说明[点击此处](docs/sd_trainer_script_installer.md)阅读。
## Qwen TTS WebUI Installer
Windows / Linux / MacOS 平台一键部署 [Qwen TTS WebUI](https://github.com/licyk/qwen-tts-webui) 的脚本，包含启动，管理 Qwen TTS WebUI 的工具。
详细的说明[点击此处](docs/qwen_tts_webui_installer.md)阅读。
## Python Installer
[install_embed_python.ps1](https://github.com/licyk/sd-webui-all-in-one/releases/download/archive/install_embed_python.ps1)([源码](https://github.com/licyk/sd-webui-all-in-one/blob/main/installer/install_embed_python.ps1))：Windows 平台一键安装便携式 Python，可用做测试。
## Installer 自动化构建状态
|Github Action|Status|
|---|---|
|Build [SD WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_webui.yml)|
|Build [SD WebUI Forge](https://github.com/lllyasviel/stable-diffusion-webui-forge) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_webui_forge.yml)|
|Build [SD WebUI reForge](https://github.com/Panchovix/stable-diffusion-webui-reForge) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_webui_reforge.yml)|
|Build [SD WebUI Forge Classic](https://github.com/Haoming02/sd-webui-forge-classic) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_webui_forge_classic.yml)|
|Build [SD Next](https://github.com/vladmandic/automatic) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_next.yml)|
|Build [ComfyUI](https://github.com/Comfy-Org/ComfyUI) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_comfyui.yml)|
|Build [Fooocus](https://github.com/lllyasviel/Fooocus) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_fooocus.yml)|
|Build [InvokeAI](https://github.com/invoke-ai/InvokeAI) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_invokeai.yml)|
|Build [SD-Trainer](https://github.com/Akegarasu/lora-scripts) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_trainer.yml)|
|Build [Kohya GUI](https://github.com/bmaltais/kohya_ss) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_kohya_gui.yml)|
|Build [SD Scripts](https://github.com/kohya-ss/sd-scripts) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_sd_scripts.yml)|
|Build [Musubi Tuner](https://github.com/kohya-ss/musubi-tuner) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_musubi_tuner.yml)|
|Build [Qwen TTS WebUI](https://github.com/licyk/qwen-tts-webui) Portable|[](https://github.com/licyk/sd-webui-all-in-one/actions/workflows/build_qwen_tts_webui.yml)|
| text/markdown | licyk | null | null | null | null | null | [
"Development Status :: 3 - Alpha",
"Operating System :: Microsoft :: Windows",
"Operating System :: POSIX :: Linux",
"Operating System :: MacOS",
"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",
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: End Users/Desktop",
"Intended Audience :: System Administrators",
"Topic :: Multimedia :: Graphics",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: System :: Installation/Setup",
"Topic :: Utilities"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"zstandard; extra == \"full\"",
"py7zr; extra == \"full\"",
"rarfile; extra == \"full\"",
"requests; extra == \"full\"",
"tqdm; extra == \"full\"",
"modelscope; extra == \"full\"",
"huggingface_hub; extra == \"full\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.11 | 2026-02-20T14:02:25.991719 | sd_webui_all_in_one-2.0.29.tar.gz | 207,710 | 35/90/6ba8ed9f41e7d0fec6313aa0668c15f2ef558fcfe900e00ab6120a2677ea/sd_webui_all_in_one-2.0.29.tar.gz | source | sdist | null | false | 78a4160b72759943e29c4bcd63be27f7 | d4735d1ad37f17972e67e11bfef51e9550316dfe092056e8a512e121cb55d3ab | 35906ba8ed9f41e7d0fec6313aa0668c15f2ef558fcfe900e00ab6120a2677ea | GPL-3.0 | [
"LICENSE"
] | 229 |
2.4 | qdrive | 0.2.57 | Dataset management and measurement library for scientific data | # qdrive
**Dataset management and measurement library for the qHarbor data platform.**
qdrive is the Python interface for creating, managing, and syncing scientific datasets with [qHarbor](https://qharbor.nl).
## Features
- 📦 **Create & manage datasets** — Store measurements with rich metadata (tags, attributes, descriptions)
- 📁 **Multi-file support with versioning** — Attach xarray, NumPy, JSON, HDF5 or any file, with automatic version tracking
- 🔍 **Powerful search** — Filter datasets by attributes, date range, tags, or text
- ☁️ **Cloud sync** — Automatic synchronization via the sync agent
- 📊 **Measurement tools** — Built-in `do0D`, `do1D`, `do2D` sweep functions using native qHarbor format, compatible with QCoDeS parameters
## Installation
```bash
pip install qdrive
```
## Quick Start
### Log in
```python
import qdrive
qdrive.launch_GUI()
```
### Create a dataset
```python
from qdrive import dataset
ds = dataset.create(
'Qubit T2* measurement',
tags=['calibration'],
attributes={'sample': 'Q7-R3', 'fridge': 'BlueFors-1'}
)
```
### Add files to a dataset
```python
import numpy as np
import xarray as xr
# Add various file types
ds['config.json'] = {'param1': 42, 'param2': 'value'}
ds['raw_data.npz'] = np.random.rand(100, 100)
ds['measurement.hdf5'] = xr.Dataset({'signal': (['time'], np.sin(np.linspace(0, 10, 100)))})
ds['script.py'] = __file__ # Attach the current script
```
### Retrieve and access data
```python
from qdrive import dataset
ds = dataset('59c40af3-cef3-49aa-8747-64707a9b080a') # Load by UUID
# Access files in multiple formats
xr_data = ds['measurement.hdf5'].xarray
json_data = ds['config.json'].json
```
### Search datasets
```python
from qdrive.dataset.search import search_datasets
results = search_datasets(
search_query='T2*',
attributes={'sample': 'Q7-R3'},
ranking=1
)
for ds in results:
print(ds.name, ds.uuid)
```
## Documentation
- 📖 [Full Documentation](https://docs.qharbor.nl)
- 🖥️ [DataQruiser App](https://docs.qharbor.nl/dataqruiser_releases.html) — Browse and visualize your data
- 💬 [Support](mailto:support@qharbor.nl)
## License
GPL-3.0 — © 2024-2026 QHarbor B.V. See [LICENCE](LICENCE) for details.
| text/markdown | QHarbor team | null | null | null | null | dataset, qcodes, data-management, hdf5, scientific-data, measurement, xarray | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"Operating System :: POSIX :: Linux",
"Operating System :: MacOS :: MacOS X",
"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",
"Topic :: Scientific/Engineering",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"PyQt5>=5.15.0",
"PyYAML>=6.0.0",
"numpy>=1.21.0",
"xarray>=2022.0.0",
"h5py>=3.0.0",
"h5netcdf>=1.0.0",
"qcodes>=0.44.0",
"prettytable>=3.0.0",
"tabulate>=0.9.0",
"tqdm>=4.0.0",
"semantic-version>=2.10.0",
"etiket-client>=0.2.57"
] | [] | [] | [] | [
"Homepage, https://qharbor.nl",
"Documentation, https://docs.qharbor.nl"
] | twine/6.2.0 CPython/3.11.12 | 2026-02-20T14:02:21.787995 | qdrive-0.2.57-py3-none-any.whl | 131,937 | e3/8e/0847ce0296b3a332f6533c330755a83aba7175fc6e76d8ac8c713bf5d259/qdrive-0.2.57-py3-none-any.whl | py3 | bdist_wheel | null | false | 5b3656e93eeffd235dea79fa68d61b6a | 32b428d42e281ac0cae67ec6e5edea02f4e9ea1d7ea886d0c2a486b6b30541a2 | e38e0847ce0296b3a332f6533c330755a83aba7175fc6e76d8ac8c713bf5d259 | GPL-3.0-only | [
"LICENCE"
] | 98 |
2.4 | gateau | 0.2.2 | GPU-Accelerated Time-dEpendent observAtion simUlator | 
[](https://doi.org/10.5281/zenodo.17183878)
Welcome to the `gateau` Github repository:
the GPU-Accelerated Time-dEpendent observAtion simUlator!
This is the end-to-end simulator for TIFUUn observations,
and is currently still in progress.
For more info, please see
[the documentation pages](https://tifuun.github.io/gateau/)
## Installation
### Installing CUDA
CUDA is an API, developed by NVIDIA, to harness the computing power of a graphics processing unit (GPU) for general purpose computing.
It provides access to the GPU's instruction set through common high-level programming languages, such as C and C++.
`gateau` uses CUDA for calculations, and hence must be installed in order to use `gateau`.
It can be [installed from source](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/) or using a [package manager](https://linuxconfig.org/how-to-install-cuda-on-ubuntu-20-04-focal-fossa-linux).
`gateau` has been tested on both CUDA version 11 and 12, so please stick to these versions.
Error-free performance on other versions is NOT guaranteed.
Even though `gateau` was exclusively developed on a [GTX 1650 Mobile](https://www.techpowerup.com/gpu-specs/geforce-gtx-1650-mobile.c3367), which is nowhere near impressive by today's standards, it is probably a good idea to use `gateau` on GPU's that meet or exceed the specs of this particular card.
### Installing gateau
Gateau is available from [pypi](https://pypi.org/project/gateau/).
You can install it like any other python package:
```
pip install gateau
```
The installation can be verified by opening a terminal, starting the python interpreter (make sure you are in the environment where `gateau` is installed), and running the following:
```
import gateau
gateau.selftest()
```
When installed correctly, the test should run without issues.
### Supported Platforms
We currently only support Linux with GNU libc
(known as `manylinux` in the Python world).
We do not ship wheels for other operating systems
or linuxes with other libc implementations.
If you want to get gateau working on one of these platforms,
have a read of [MAINTAINERS.md](./MAINTAINERS.md)
(and please let us know if you're interested in helping
us get gateau running on other platforms!).
## For maintainers and developers
For information on things like running tests
and making new releases of Gateau,
please consult [MAINTAINERS.md](./MAINTAINERS.md).
For contribution guidelines, see [CONTRIBUTING.md](./CONTRIBUTING.md)
## License
Gateau 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, version 3 of the License only.
Gateau 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 Gateau. If not, see https://www.gnu.org/licenses/.
Note: Previous versions of gateau were released under different licenses. If the
current license does not meet your needs, you may consider using an earlier
version under the terms of its original license. You can find these versions by
browsing the commit history.
---
Copyright (c) 2025, maybetree, Arend Moerman.
| text/markdown | Arend Moerman | maybetree <maybetree48@proton.me> | null | null | null | null | [
"Programming Language :: Python :: 3",
"Programming Language :: C",
"Programming Language :: C++",
"Environment :: GPU :: NVIDIA CUDA :: 11",
"Operating System :: OS Independent"
] | [] | null | null | >=3.9 | [] | [] | [] | [
"numpy",
"matplotlib",
"scipy",
"tqdm",
"astropy",
"psutil",
"h5py",
"pip-tools; extra == \"dev\"",
"wheel-filename; extra == \"dev\"",
"jupyter; extra == \"doxy\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.12.10 | 2026-02-20T14:02:09.862975 | gateau-0.2.2.tar.gz | 567,077 | a7/2e/4f8fdba8da5bd3b6dd6c327fc151f9ae71b72f1ef5fc3db7c252793793c5/gateau-0.2.2.tar.gz | source | sdist | null | false | cffd4064f400276f5447abf38fdff104 | 0db8d3f9994fb2debe611c0582dfb2810cd89e3f1b583b42514894d5bc7a41be | a72e4f8fdba8da5bd3b6dd6c327fc151f9ae71b72f1ef5fc3db7c252793793c5 | AGPL-3.0-only | [] | 218 |
2.4 | etiket-client | 0.2.57 | Python client library to interact with the eTiKeT/qHarbor platform | # Etiket Client
A Python client for interacting with the Etiket data management platform. Provides seamless access to datasets with automatic synchronization between local and remote storage.
## Installation
```bash
pip install etiket_client
```
**Requirements:** Python 3.10+
> **Note:** This is a library, not intended for direct end-user use. It serves as the backbone for QDrive
## Architecture
The client is organized into several modules:
| Module | Description |
|--------|-------------|
| `local` | Local SQLite database that mirrors part of the remote database, enabling full offline workflow for downloaded datasets |
| `python_api` | High-level API for scopes, datasets, and files |
| `remote` | HTTP client, authentication, and server communication |
| `settings` | Configuration and user preferences |
| `sync` | Synchronization logic between local and remote data |
## License
See [LICENCE](LICENCE) for details.
| text/markdown | QHarbor team | null | null | null | null | etiket, qharbor, client, api, scientific-data, data-management | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Operating System :: POSIX :: Linux",
"Operating System :: MacOS :: MacOS X",
"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",
"Topic :: Scientific/Engineering",
"Topic :: Software Development :: Libraries :: Python Modules"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"SQLAlchemy>=2.0.0",
"alembic>=1.10.0",
"pydantic<3.0.0,>=2.5.0",
"requests>=2.28.0",
"tqdm>=4.64.0",
"tabulate>=0.9.0",
"filelock>=3.4.0",
"platformdirs>=4.0.0",
"numpy>=1.21.0",
"email-validator>=2.0.0",
"python-dateutil>=2.8.2",
"semantic-version>=2.10.0",
"requests-oauthlib>=2.0.0",
"regex>=2024.1.0",
"PyYAML>=6.0.0",
"watchdog>=4.0.0",
"setproctitle>=1.3.0",
"packaging>=23.0",
"xarray>=2022.0.0",
"h5netcdf>=1.0.0",
"h5py>=3.8.0",
"psutil>=5.9.0",
"pytest>=8.0; extra == \"test\"",
"pytest>=8.0; extra == \"dev\"",
"qcodes>=0.35.0; extra == \"qcodes\""
] | [] | [] | [] | [
"Homepage, https://qharbor.nl",
"Documentation, https://docs.qharbor.nl"
] | twine/6.2.0 CPython/3.11.12 | 2026-02-20T14:02:08.955352 | etiket_client-0.2.57-py3-none-any.whl | 226,628 | 0f/f9/6d3d0971255d3defccb967100b22f10dcc906991c626cefd295f9634c033/etiket_client-0.2.57-py3-none-any.whl | py3 | bdist_wheel | null | false | f719ae5fc39f4cb584e690acebf1c505 | d1ab6149f2315ddd8807f24b00180a72d06a2336c5d993758babdfee152d4a67 | 0ff96d3d0971255d3defccb967100b22f10dcc906991c626cefd295f9634c033 | LicenseRef-Proprietary | [
"LICENCE"
] | 111 |
2.4 | fasttransfer-mcp | 0.1.1 | A Model Context Protocol (MCP) server for FastTransfer, enabling efficient data transfer between database systems. | # FastTransfer MCP Server
<!-- mcp-name: io.github.aetperf/fasttransfer-mcp -->
A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that exposes [FastTransfer](https://aetperf.github.io/FastTransfer-Documentation/) functionality for efficient data transfer between various database systems.
## Overview
FastTransfer is a high-performance CLI tool for transferring data between databases. This MCP server wraps FastTransfer functionality and provides:
- **Safety-first approach**: Preview commands before execution with user confirmation required
- **Password masking**: Credentials and connection strings are never displayed in logs or output
- **Intelligent validation**: Parameter validation with database-specific compatibility checks
- **Smart suggestions**: Automatic parallelism method recommendations
- **Version detection**: Automatic binary version detection with capability registry
- **Comprehensive logging**: Full execution logs with timestamps and results
## MCP Tools
### 1. `preview_transfer_command`
Build and preview a FastTransfer command WITHOUT executing it. Shows the exact command with passwords masked. Always use this first.
### 2. `execute_transfer`
Execute a previously previewed command. Requires `confirmation: true` as a safety mechanism.
### 3. `validate_connection`
Validate database connection parameters (parameter check only, does not test actual connectivity).
### 4. `list_supported_combinations`
List all supported source-to-target database combinations.
### 5. `suggest_parallelism_method`
Recommend the optimal parallelism method based on source database type and table characteristics.
### 6. `get_version`
Report the detected FastTransfer binary version, supported types, and feature flags.
## Installation
### Prerequisites
- Python 3.10 or higher
- FastTransfer binary v0.16+ (obtain from [Arpe.io](https://arpe.io))
- Claude Code or another MCP client
### Setup
1. **Clone or download this repository**:
```bash
cd /path/to/fasttransfer-mcp
```
2. **Install Python dependencies**:
```bash
pip install -r requirements.txt
```
3. **Configure environment**:
```bash
cp .env.example .env
# Edit .env with your FastTransfer path
```
4. **Add to Claude Code configuration** (`~/.claude.json`):
```json
{
"mcpServers": {
"fasttransfer": {
"type": "stdio",
"command": "python",
"args": ["/absolute/path/to/fasttransfer-mcp/src/server.py"],
"env": {
"FASTTRANSFER_PATH": "/absolute/path/to/fasttransfer/FastTransfer"
}
}
}
}
```
5. **Restart Claude Code** to load the MCP server.
6. **Verify installation**:
```
# In Claude Code, run:
/mcp
# You should see "fasttransfer: connected"
```
## Configuration
### Environment Variables
Edit `.env` to configure:
```bash
# Path to FastTransfer binary (required)
FASTTRANSFER_PATH=./fasttransfer/FastTransfer
# Execution timeout in seconds (default: 1800 = 30 minutes)
FASTTRANSFER_TIMEOUT=1800
# Log directory (default: ./logs)
FASTTRANSFER_LOG_DIR=./logs
# Log level (default: INFO)
LOG_LEVEL=INFO
```
## Connection Options
The server supports multiple ways to authenticate and connect:
| Parameter | Description |
|-----------|-------------|
| `server` | Host:port or host\instance (optional with `connect_string` or `dsn`) |
| `user` / `password` | Standard credentials |
| `trusted_auth` | Windows trusted authentication |
| `connect_string` | Full connection string (excludes server/user/password/dsn) |
| `dsn` | ODBC DSN name (excludes server/provider) |
| `provider` | OleDB provider name |
| `file_input` | File path for data input (source only, excludes query) |
## Transfer Options
| Option | CLI Flag | Description |
|--------|----------|-------------|
| `method` | `--method` | Parallelism method |
| `distribute_key_column` | `--distributeKeyColumn` | Column for data distribution |
| `degree` | `--degree` | Parallelism degree (0=auto, >0=fixed, <0=CPU adaptive) |
| `load_mode` | `--loadmode` | Append or Truncate |
| `batch_size` | `--batchsize` | Batch size for bulk operations |
| `map_method` | `--mapmethod` | Column mapping: Position or Name |
| `run_id` | `--runid` | Run ID for logging |
| `data_driven_query` | `--datadrivenquery` | Custom SQL for DataDriven method |
| `use_work_tables` | `--useworktables` | Intermediate work tables for CCI |
| `settings_file` | `--settingsfile` | Custom settings JSON file |
| `log_level` | `--loglevel` | Override log level (error/warning/information/debug/fatal) |
| `no_banner` | `--nobanner` | Suppress banner output |
| `license_path` | `--license` | License file path or URL |
## Usage Examples
### PostgreSQL to SQL Server Transfer
```
User: "Copy the 'orders' table from PostgreSQL (localhost:5432, database: sales_db,
schema: public) to SQL Server (localhost:1433, database: warehouse, schema: dbo).
Use parallel transfer and truncate the target first."
Claude Code will:
1. Call suggest_parallelism_method to recommend Ctid for PostgreSQL
2. Call preview_transfer_command with your parameters
3. Show the command with masked passwords
4. Explain what will happen
5. Ask for confirmation
6. Execute with execute_transfer when you approve
```
### File Import via DuckDB Stream
```
User: "Import /data/export.parquet into the SQL Server 'staging' table
using DuckDB stream."
Claude Code will use duckdbstream source type with file_input parameter.
```
### Check Version and Capabilities
```
User: "What version of FastTransfer is installed?"
Claude Code will call get_version and display the detected version,
supported source/target types, and available features.
```
## Two-Step Safety Process
This server implements a mandatory two-step process:
1. **Preview** - Always use `preview_transfer_command` first
2. **Execute** - Use `execute_transfer` with `confirmation: true`
You cannot execute without previewing first and confirming.
## Security
- Passwords and connection strings are masked in all output and logs
- Sensitive flags masked: `--sourcepassword`, `--targetpassword`, `--sourceconnectstring`, `--targetconnectstring`, `-x`, `-X`, `-g`, `-G`
- Use environment variables for sensitive configuration
- Review commands carefully before executing
- Use minimum required database permissions
## Testing
Run the test suite:
```bash
# Run all tests
python -m pytest tests/ -v
# Run with coverage
python -m pytest tests/ --cov=src --cov-report=html
```
## Project Structure
```
fasttransfer-mcp/
src/
__init__.py
server.py # MCP server (tool definitions, handlers)
fasttransfer.py # Command builder, executor, suggestions
validators.py # Pydantic models, enums, validation
version.py # Version detection and capabilities registry
tests/
__init__.py
test_command_builder.py
test_validators.py
test_version.py
.env.example
requirements.txt
CHANGELOG.md
README.md
```
## License
This MCP server wrapper is provided as-is. FastTransfer itself is a separate product from Arpe.io.
## Related Links
- [FastTransfer Documentation](https://aetperf.github.io/FastTransfer-Documentation/)
- [Model Context Protocol](https://modelcontextprotocol.io/)
| text/markdown | Arpe.io | null | null | null | null | data-transfer, database, etl, fasttransfer, mcp, model-context-protocol | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"mcp>=1.0.0",
"pydantic>=2.0.0",
"python-dotenv>=1.0.0",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest-cov>=4.1.0; extra == \"dev\"",
"pytest-mock>=3.11.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://aetperf.github.io/FastTransfer-Documentation/",
"Repository, https://github.com/aetperf/fasttransfer-mcp",
"Issues, https://github.com/aetperf/fasttransfer-mcp/issues"
] | twine/6.2.0 CPython/3.13.9 | 2026-02-20T14:01:15.054553 | fasttransfer_mcp-0.1.1.tar.gz | 33,159 | db/4f/104eb9df914d1969931e7d3ea0d8bacec9e1aac62ccbe96a9c70be89cad4/fasttransfer_mcp-0.1.1.tar.gz | source | sdist | null | false | 134e57616b69cb6d806a5e11439355be | 38e70871e48d654fdd0a9488b3e22505b54d7119fd820a4bed03f673456faaaf | db4f104eb9df914d1969931e7d3ea0d8bacec9e1aac62ccbe96a9c70be89cad4 | MIT | [
"LICENSE"
] | 209 |
2.4 | netcdf2region | 0.1.5 | Aggregate NetCDF data to regions using spatial weights | # netcdf2region
`netcdf2region` is a Python package providing command-line tools for aggregating gridded NetCDF files over regions defined by shapefiles. It is designed to facilitate spatial analysis and extraction of regional statistics from large climate or geospatial datasets.
## Features
- Aggregate gridded NetCDF data by custom regions (e.g., administrative boundaries, ecozones).
- Support for shapefile-based region definitions.
- Efficient processing of large datasets.
- Command-line interface for easy integration into workflows.
## Installation
```bash
pip install netcdf2region
```
## Disclaimer
This package is still in the early stages of development. Please check that all outputs are valid, as errors during calculation may still occur.
## Usage
### 1. Compute Grid Weights
The `compute_grid_weights` command estimates the overlap between NetCDF grid cells and regions defined in a shapefile via point sampling. This step is performed separately to enable efficient repeated aggregations. The package also provides precomputed weights for common grids, such as ERA5, and shapefiles, such as GADM 3.6. See the section 'Precomputed weights' for more information.
```bash
compute_grid_weights <netcdf> <shapefile> <output> [options]
```
#### Positional Arguments
- `<netcdf>`: Path to the NetCDF file with latitude/longitude grid.
- `<shapefile>`: Path to the shapefile defining regions (e.g., `.shp`).
- `<output>`: Path to the output CSV file for computed grid weights.
#### Options
- `--points_per_cell <int>`: Number of random points per grid cell (default: 100).
- `--point_distribution <uniform|random>`: Distribution of points within grid cells (default: uniform)
- `--simplify`: Simplify region geometries for faster computation.
- `--land_sea_mask <file>`: Path to a land-sea mask NetCDF file for faster computation (optional).
- `--shapefile_layer <int>`: Layer number in the shapefile to use (default: first layer).
- `--backend <str>`: Parallel backend to use (`threading` by default).
- `--n_jobs <int>`: Number of parallel jobs (default: 8).
- `--coordinate_origin <str>`: Coordinate origin of the grid (default: centered).
- `--gid <str>`: Geo identifier of the shapefile (default: GID_1)
- `--shift_longitudes`: Shift longitudes from [0, 360] to [-180, 180]
- `--yes`: Automatically answer yes to prompts.
See `--help` for more details.
### 2. Aggregate NetCDF Data
The `netcdf2region` command aggregates gridded NetCDF data over regions using precomputed grid weights, which are estimated via the `compute_grid_weights` command. The package also provides precomputed weights for common grids, such as ERA5, and shapefiles, such as GADM 3.6. These can be used directly with the `--precalc_weights` option (see the section 'Precomputed weights').
```bash
netcdf2region \
--netcdf <input.nc> \
(--weights <weights.csv> | --precalc_weights <precalc_weights_name>) \
--method <mean|sum|std> \
--output <output.csv> \
--var <variable_name> \
[--correct_weights] \
[--time_var <time_variable>]
```
#### Arguments
- `--netcdf`: Path to the input NetCDF file.
- `--weights`: Path to the CSV file with grid weights (`lat,lon,region_id,percent_overlap`). Mutually exclusive with `--precalc_weights`.
- `--precalc_weights`: Name of a predefined weights file (e.g., `ERA5_to_GADM36_admin1_weights.csv`). Mutually exclusive with `--weights`.
- `--method`: Aggregation method (`mean`, `sum`, or `std`).
- `--output`: Path to the output CSV file.
- `--var`: Name of the variable in the NetCDF file to aggregate.
- `--correct_weights`: (Optional) If set, corrects weights to ensure no values are attributed to the sea.
- `--time_var`: (Optional) Name of the time variable in the NetCDF file (if not automatically detected).
^^
See the command-line help (`--help`) for more options and details.
## Precomputed weights
The package provides precomputed weights for standard grids and shapefiles that can be used immediately with the `netcdf2region` command.
| Grid | Shapefile | Weights file |
|--------------|-------------------|----------------------------------------------|
| ISIMIP 0.5° | GADM 3.6 Admin 0 | ISIMIP_to_GADM36_admin0_weights.csv |
| ISIMIP 0.5° | GADM 3.6 Admin 1 | ISIMIP_to_GADM36_admin1_weights.csv |
| ISIMIP 0.5° | DOSE V2 Admin 1 | ISIMIP_to_DOSE_admin1_weights.csv |
| ERA5 0.25° | GADM 3.6 Admin 0 | ERA5_to_GADM36_admin0_weights.csv |
| ERA5 0.25° | GADM 3.6 Admin 1 | ERA5_to_GADM36_admin1_weights.csv |
| ERA5 0.25° | DOSE Admin 1 | ERA5_to_DOSE_admin1_weights.csv |
### Example: Using Precomputed Weights
To aggregate NetCDF data using precomputed weights, specify the `--precalc_weights` option with the name of the weights file. For example, to aggregate ERA5 data over GADM 3.6 Admin 1 regions:
```bash
netcdf2region \
--netcdf ERA5_sample.nc \
--precalc_weights ERA5_to_GADM36_admin1_weights.csv \
--method mean \
--output ERA5_admin1_mean.csv \
--var temperature
```
This command computes the mean of the `temperature` variable for each region defined in the GADM 3.6 Admin 1 shapefile using the precomputed weights.
## Example of Executing Weight Calculations on a HPC with Slurm Workload Manager
This example assumes that the Python environment 'netcdf2region_env' is available, with the package installed:
```bash
conda create -n netcdf2region_env -c anaconda
pip install /path/to/netcdf2region
```
SLURM script to be executed with `sbatch`:
```bash
#!/bin/bash
#SBATCH --qos=priority
#SBATCH --account=<account_name>
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=16
#SBATCH --mem=60000
# Setup python environment
module purge
module load anaconda
source activate netcdf2region_env
# Setup paths
NETCDF_GRID="ERA5_sample.nc"
SHAPEFILE="gadm36_levels.gpkg"
SHAPEFILE_LAYER=1
WEIGHTS_OUTPUT="ERA5_to_GADM36_admin1_weights.csv"
# Settings for parallel computation
NUMBER_OF_JOBS=16 # Number of parallel jobs set to the number of CPU cores
# Run the Python script
compute_grid_weights $NETCDF_GRID $SHAPEFILE $WEIGHTS_OUTPUT --yes --shapefile_layer=$SHAPEFILE_LAYER --n_jobs=$NUMBER_OF_JOBS
```
## Requirements
- Python 3.7+
- numpy
- pandas
- xarray
- rasterio
- geopandas
- matplotlib
- shapely
- joblib
- scipy
- tqdm
- netCDF4
## Contributing
Contributions are welcome! Please open issues or pull requests.
| text/markdown | null | Jakob Wedemeyer <jakob.wedemeyer@pik-potsdam.de> | null | null | null | null | [] | [] | null | null | null | [] | [] | [] | [
"numpy",
"pandas",
"xarray",
"rasterio",
"geopandas",
"matplotlib",
"shapely",
"joblib",
"scipy",
"tqdm",
"netcdf4"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.18 | 2026-02-20T14:00:45.501500 | netcdf2region-0.1.5.tar.gz | 4,276,506 | d9/43/a018644470f4c5fb7b7e49ab1d716b1cb99afaca08e92a50322ebc5b6a67/netcdf2region-0.1.5.tar.gz | source | sdist | null | false | 161a277e6a99306610bf449dfdcf8d10 | 034e33b61229655d74b1d093c8aa35b790a8dcec384b0d4bdfa72987075ea8c0 | d943a018644470f4c5fb7b7e49ab1d716b1cb99afaca08e92a50322ebc5b6a67 | null | [] | 216 |
2.4 | gnosis-mcp | 0.7.13 | Zero-config MCP server for searchable documentation (SQLite default, PostgreSQL optional) | <!-- mcp-name: io.github.nicholasglazer/gnosis -->
<div align="center">
<h1>Gnosis MCP</h1>
<p><strong>Give your AI agent a searchable knowledge base. Zero config.</strong></p>
<p>
<a href="https://pypi.org/project/gnosis-mcp/"><img src="https://img.shields.io/pypi/v/gnosis-mcp?color=blue" alt="PyPI"></a>
<a href="https://pypi.org/project/gnosis-mcp/"><img src="https://img.shields.io/pypi/pyversions/gnosis-mcp" alt="Python"></a>
<a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="MIT License"></a>
<a href="https://github.com/nicholasglazer/gnosis-mcp/actions"><img src="https://github.com/nicholasglazer/gnosis-mcp/actions/workflows/publish.yml/badge.svg" alt="CI"></a>
<a href="https://registry.modelcontextprotocol.io"><img src="https://img.shields.io/badge/MCP-Registry-blue" alt="MCP Registry"></a>
</p>
<p>
<a href="#quick-start">Quick Start</a> ·
<a href="#choose-your-backend">Backends</a> ·
<a href="#editor-integrations">Editor Setup</a> ·
<a href="#what-it-does">Tools & Resources</a> ·
<a href="#configuration">Configuration</a> ·
<a href="llms-full.txt">Full Reference</a>
</p>
<a href="https://miozu.com/products/gnosis-mcp"><img src="https://miozu.com/oss/gnosis-mcp-demo.gif" alt="Gnosis MCP demo — ingest, search, serve" width="700"></a>
</div>
---
AI coding agents can read your source code but not your documentation. They guess at architecture, miss established patterns, and hallucinate details they could have looked up.
Gnosis MCP fixes this. Point it at a folder of docs and it creates a searchable knowledge base that any [MCP](https://modelcontextprotocol.io/)-compatible AI agent can query — Claude Code, Cursor, Windsurf, Cline, and any tool that supports the Model Context Protocol.
**No database server.** SQLite works out of the box with keyword search, or add `[embeddings]` for local semantic search. Scale to PostgreSQL + pgvector when needed.
## Why use this
**Less hallucination.** Agents search your docs before guessing. Architecture decisions, API contracts, billing rules — one tool call away instead of made up.
**Lower token costs.** A search returns ~600 tokens of ranked results. Reading the same docs as files costs 3,000-8,000+ tokens. On a 170-doc knowledge base (~840K tokens), that's the difference between a precise answer and a blown context window.
**Docs that stay current.** Add a new markdown file, run `ingest`, it's searchable immediately. Or use `--watch` to auto-re-ingest on file changes. No routing tables to maintain, no hardcoded paths to update.
**Works with what you have.** Gnosis MCP ingests `.md`, `.txt`, `.ipynb`, `.toml`, `.csv`, and `.json` files. Non-markdown formats are auto-converted for chunking — zero extra dependencies.
## Quick Start
```bash
pip install gnosis-mcp
gnosis-mcp ingest ./docs/ # loads docs, auto-creates SQLite database
gnosis-mcp serve # starts MCP server
```
That's it. Your AI agent can now search your docs.
**Want semantic search?** Add local ONNX embeddings (no API key needed, ~23MB model):
```bash
pip install gnosis-mcp[embeddings]
gnosis-mcp ingest ./docs/ --embed # ingest + embed in one step
gnosis-mcp serve # hybrid keyword+semantic search auto-activated
```
Test it before connecting to an editor:
```bash
gnosis-mcp search "getting started" # keyword search
gnosis-mcp search "how does auth work" --embed # hybrid semantic+keyword
gnosis-mcp stats # see what was indexed
```
<details>
<summary>Try without installing (uvx)</summary>
```bash
uvx gnosis-mcp ingest ./docs/
uvx gnosis-mcp serve
```
</details>
## Editor Integrations
Gnosis MCP works with any MCP-compatible editor. Add the server config, and your AI agent gets `search_docs`, `get_doc`, and `get_related` tools automatically.
### Claude Code
Add to `.claude/mcp.json`:
```json
{
"mcpServers": {
"docs": {
"command": "gnosis-mcp",
"args": ["serve"]
}
}
}
```
Or install as a [Claude Code plugin](#claude-code-plugin) for a richer experience with slash commands.
### Cursor
Add to `.cursor/mcp.json`:
```json
{
"mcpServers": {
"docs": {
"command": "gnosis-mcp",
"args": ["serve"]
}
}
}
```
### Windsurf
Add to `~/.codeium/windsurf/mcp_config.json`:
```json
{
"mcpServers": {
"docs": {
"command": "gnosis-mcp",
"args": ["serve"]
}
}
}
```
### VS Code (GitHub Copilot)
Add to `.vscode/mcp.json` in your workspace:
```json
{
"servers": {
"docs": {
"command": "gnosis-mcp",
"args": ["serve"]
}
}
}
```
Also discoverable via the VS Code MCP gallery — search `@mcp gnosis` in the Extensions view.
> **Enterprise:** Your org admin needs the "MCP servers in Copilot" policy enabled. Free/Pro/Pro+ plans work without this.
### JetBrains (IntelliJ, PyCharm, WebStorm)
Go to **Settings > Tools > AI Assistant > MCP Servers**, click **+**, and add:
- **Name:** `docs`
- **Command:** `gnosis-mcp`
- **Arguments:** `serve`
### Cline
Open Cline MCP settings panel and add the same server config.
### Other MCP clients
Any tool that supports the [Model Context Protocol](https://modelcontextprotocol.io/) works — including Zed, Neovim (via plugins), and custom agents. The server communicates over stdio by default, or Streamable HTTP for remote deployment:
```bash
gnosis-mcp serve --transport streamable-http --host 0.0.0.0 --port 8000
# Remote clients connect to http://your-server:8000/mcp
```
## Choose Your Backend
| | SQLite (default) | SQLite + embeddings | PostgreSQL |
|---|---|---|---|
| **Install** | `pip install gnosis-mcp` | `pip install gnosis-mcp[embeddings]` | `pip install gnosis-mcp[postgres]` |
| **Config** | Nothing | Nothing | Set `DATABASE_URL` |
| **Search** | FTS5 keyword (BM25) | Hybrid keyword + semantic (RRF) | tsvector + pgvector hybrid |
| **Embeddings** | None | Local ONNX (23MB, no API key) | Any provider + HNSW index |
| **Multi-table** | No | No | Yes (`UNION ALL`) |
| **Best for** | Quick start, keyword-only | Semantic search without a server | Production, large doc sets |
**Auto-detection:** Set `DATABASE_URL` to `postgresql://...` and it uses PostgreSQL. Don't set it and it uses SQLite. Override with `GNOSIS_MCP_BACKEND=sqlite|postgres`.
<details>
<summary>PostgreSQL setup</summary>
```bash
pip install gnosis-mcp[postgres]
export GNOSIS_MCP_DATABASE_URL="postgresql://user:pass@localhost:5432/mydb"
gnosis-mcp init-db # create tables + indexes
gnosis-mcp ingest ./docs/ # load your markdown
gnosis-mcp serve
```
For hybrid semantic+keyword search, also enable pgvector:
```sql
CREATE EXTENSION IF NOT EXISTS vector;
```
Then backfill embeddings:
```bash
gnosis-mcp embed # via OpenAI (default)
gnosis-mcp embed --provider ollama # or use local Ollama
```
</details>
## Claude Code Plugin
For Claude Code users, install as a plugin to get the MCP server plus slash commands:
```bash
claude plugin marketplace add nicholasglazer/gnosis-mcp
claude plugin install gnosis
```
This gives you:
| Component | What you get |
|-----------|-------------|
| **MCP server** | `gnosis-mcp serve` — auto-configured |
| **`/gnosis:search`** | Search docs with keyword or `--semantic` hybrid mode |
| **`/gnosis:status`** | Health check — connectivity, doc stats, troubleshooting |
| **`/gnosis:manage`** | CRUD — add, delete, update metadata, bulk embed |
The plugin works with both SQLite and PostgreSQL backends.
<details>
<summary>Manual setup (without plugin)</summary>
Add to `.claude/mcp.json`:
```json
{
"mcpServers": {
"gnosis": {
"command": "gnosis-mcp",
"args": ["serve"]
}
}
}
```
For PostgreSQL, add `"env": {"GNOSIS_MCP_DATABASE_URL": "postgresql://..."}`.
</details>
## What It Does
Gnosis MCP exposes 6 tools and 3 resources over MCP. Your AI agent calls these automatically when it needs information from your docs.
### Tools
| Tool | What it does | Mode |
|------|-------------|------|
| `search_docs` | Search by keyword or hybrid semantic+keyword | Read |
| `get_doc` | Retrieve a full document by path | Read |
| `get_related` | Find linked/related documents | Read |
| `upsert_doc` | Create or replace a document | Write |
| `delete_doc` | Remove a document and its chunks | Write |
| `update_metadata` | Change title, category, tags | Write |
Read tools are always available. Write tools require `GNOSIS_MCP_WRITABLE=true`.
### Resources
| URI | Returns |
|-----|---------|
| `gnosis://docs` | All documents — path, title, category, chunk count |
| `gnosis://docs/{path}` | Full document content |
| `gnosis://categories` | Categories with document counts |
### How search works
```bash
# Keyword search — works on both SQLite and PostgreSQL
gnosis-mcp search "stripe webhook"
# Hybrid search — keyword + semantic similarity (PostgreSQL + embeddings)
gnosis-mcp search "how does billing work" --embed
# Filtered — narrow results to a specific category
gnosis-mcp search "auth" -c guides
```
When called via MCP, the agent passes a `query` string for keyword search. On PostgreSQL with embeddings, it can also pass `query_embedding` for hybrid mode that combines keyword matching with semantic similarity.
Search results include a `highlight` field with matched terms wrapped in `<mark>` tags for context-aware snippets (FTS5 `snippet()` on SQLite, `ts_headline()` on PostgreSQL).
## Embeddings
Embeddings enable semantic search — finding docs by meaning, not just keywords.
**1. Local ONNX (recommended for SQLite)** — zero-config, no API key needed:
```bash
pip install gnosis-mcp[embeddings]
gnosis-mcp ingest ./docs/ --embed # ingest + embed in one step
gnosis-mcp embed # or embed existing chunks separately
```
Uses [MongoDB/mdbr-leaf-ir](https://huggingface.co/MongoDB/mdbr-leaf-ir) (~23MB quantized, Apache 2.0). Auto-downloads on first run. Customize with `GNOSIS_MCP_EMBED_MODEL`.
**2. Remote providers** — OpenAI, Ollama, or any OpenAI-compatible endpoint:
```bash
gnosis-mcp embed --provider openai # requires GNOSIS_MCP_EMBED_API_KEY
gnosis-mcp embed --provider ollama # uses local Ollama server
```
**3. Pre-computed vectors** — pass `embeddings` to `upsert_doc` or `query_embedding` to `search_docs` from your own pipeline.
**Hybrid search** — when embeddings are available, search automatically combines keyword (BM25) and semantic (cosine) results using Reciprocal Rank Fusion (RRF). Works on both SQLite (via sqlite-vec) and PostgreSQL (via pgvector).
## Configuration
All settings via environment variables. Nothing required for SQLite — it works with zero config.
| Variable | Default | Description |
|----------|---------|-------------|
| `GNOSIS_MCP_DATABASE_URL` | SQLite auto | PostgreSQL URL or SQLite file path |
| `GNOSIS_MCP_BACKEND` | `auto` | Force `sqlite` or `postgres` |
| `GNOSIS_MCP_WRITABLE` | `false` | Enable write tools (`upsert_doc`, `delete_doc`, `update_metadata`) |
| `GNOSIS_MCP_TRANSPORT` | `stdio` | Server transport: `stdio` or `sse` |
| `GNOSIS_MCP_SCHEMA` | `public` | Database schema (PostgreSQL only) |
| `GNOSIS_MCP_CHUNKS_TABLE` | `documentation_chunks` | Table name for chunks |
| `GNOSIS_MCP_SEARCH_FUNCTION` | — | Custom search function (PostgreSQL only) |
| `GNOSIS_MCP_EMBEDDING_DIM` | `1536` | Vector dimension for init-db |
<details>
<summary>All variables</summary>
**Search & chunking:** `GNOSIS_MCP_CONTENT_PREVIEW_CHARS` (200), `GNOSIS_MCP_CHUNK_SIZE` (4000), `GNOSIS_MCP_SEARCH_LIMIT_MAX` (20).
**Connection pool (PostgreSQL):** `GNOSIS_MCP_POOL_MIN` (1), `GNOSIS_MCP_POOL_MAX` (3).
**Webhooks:** `GNOSIS_MCP_WEBHOOK_URL`, `GNOSIS_MCP_WEBHOOK_TIMEOUT` (5s). Set a URL to receive POST notifications when documents are created, updated, or deleted.
**Embeddings:** `GNOSIS_MCP_EMBED_PROVIDER` (openai/ollama/custom/local), `GNOSIS_MCP_EMBED_MODEL` (text-embedding-3-small for remote, MongoDB/mdbr-leaf-ir for local), `GNOSIS_MCP_EMBED_DIM` (384, Matryoshka truncation dimension for local provider), `GNOSIS_MCP_EMBED_API_KEY`, `GNOSIS_MCP_EMBED_URL` (custom endpoint), `GNOSIS_MCP_EMBED_BATCH_SIZE` (50).
**Column overrides** (for connecting to existing tables with non-standard column names): `GNOSIS_MCP_COL_FILE_PATH`, `GNOSIS_MCP_COL_TITLE`, `GNOSIS_MCP_COL_CONTENT`, `GNOSIS_MCP_COL_CHUNK_INDEX`, `GNOSIS_MCP_COL_CATEGORY`, `GNOSIS_MCP_COL_AUDIENCE`, `GNOSIS_MCP_COL_TAGS`, `GNOSIS_MCP_COL_EMBEDDING`, `GNOSIS_MCP_COL_TSV`, `GNOSIS_MCP_COL_SOURCE_PATH`, `GNOSIS_MCP_COL_TARGET_PATH`, `GNOSIS_MCP_COL_RELATION_TYPE`.
**Links table:** `GNOSIS_MCP_LINKS_TABLE` (documentation_links).
**Logging:** `GNOSIS_MCP_LOG_LEVEL` (INFO).
</details>
<details>
<summary>Custom search function (PostgreSQL)</summary>
Delegate search to your own PostgreSQL function for custom ranking:
```sql
CREATE FUNCTION my_schema.my_search(
p_query_text text,
p_categories text[],
p_limit integer
) RETURNS TABLE (
file_path text, title text, content text,
category text, combined_score double precision
) ...
```
```bash
GNOSIS_MCP_SEARCH_FUNCTION=my_schema.my_search
```
</details>
<details>
<summary>Multi-table mode (PostgreSQL)</summary>
Query across multiple doc tables:
```bash
GNOSIS_MCP_CHUNKS_TABLE=documentation_chunks,api_docs,tutorial_chunks
```
All tables must share the same schema. Reads use `UNION ALL`. Writes target the first table.
</details>
## CLI Reference
```
gnosis-mcp ingest <path> [--dry-run] [--force] [--embed] Load files (--force to re-ingest unchanged)
gnosis-mcp serve [--transport stdio|sse] [--ingest PATH] [--watch PATH] Start MCP server (--watch for live reload)
gnosis-mcp search <query> [-n LIMIT] [-c CAT] [--embed] Search (--embed for hybrid semantic+keyword)
gnosis-mcp stats Show document, chunk, and embedding counts
gnosis-mcp check Verify database connection + sqlite-vec status
gnosis-mcp embed [--provider P] [--model M] [--dry-run] Backfill embeddings (auto-detects local provider)
gnosis-mcp init-db [--dry-run] Create tables + indexes manually
gnosis-mcp export [-f json|markdown|csv] [-c CAT] Export documents
gnosis-mcp diff <path> Show what would change on re-ingest
```
## How ingestion works
`gnosis-mcp ingest` scans a directory for supported files (`.md`, `.txt`, `.ipynb`, `.toml`, `.csv`, `.json`) and loads them into the database:
- **Multi-format** — Markdown native; `.txt`, `.ipynb`, `.toml`, `.csv`, `.json` auto-converted (stdlib only). Optional: `.rst` (`pip install gnosis-mcp[rst]`), `.pdf` (`pip install gnosis-mcp[pdf]`)
- **Smart chunking** — splits by H2 headings (H3/H4 for oversized sections), never splits inside fenced code blocks or tables
- **Frontmatter support** — extracts `title`, `category`, `audience`, `tags` from YAML frontmatter
- **Auto-linking** — `relates_to` in frontmatter creates bidirectional links (queryable via `get_related`)
- **Auto-categorization** — infers category from the parent directory name
- **Incremental updates** — content hashing skips unchanged files on re-run (`--force` to override)
- **Watch mode** — `gnosis-mcp serve --watch ./docs/` auto-re-ingests on file changes
- **Dry run** — preview what would be indexed with `--dry-run`
## Available on
Gnosis MCP is listed on the [Official MCP Registry](https://registry.modelcontextprotocol.io) (which feeds the VS Code MCP gallery and GitHub Copilot), [PyPI](https://pypi.org/project/gnosis-mcp/), and major MCP directories including [mcp.so](https://mcp.so), [Glama](https://glama.ai), and [cursor.directory](https://cursor.directory).
## Architecture
```
src/gnosis_mcp/
├── backend.py DocBackend protocol + create_backend() factory
├── pg_backend.py PostgreSQL — asyncpg, tsvector, pgvector
├── sqlite_backend.py SQLite — aiosqlite, FTS5, sqlite-vec hybrid search (RRF)
├── sqlite_schema.py SQLite DDL — tables, FTS5, triggers, vec0 virtual table
├── config.py Config from env vars, backend auto-detection
├── db.py Backend lifecycle + FastMCP lifespan
├── server.py FastMCP server — 6 tools, 3 resources, auto-embed queries
├── ingest.py File scanner + converters — multi-format, smart chunking (H2/H3/H4)
├── watch.py File watcher — mtime polling, auto-re-ingest on changes
├── schema.py PostgreSQL DDL — tables, indexes, search functions
├── embed.py Embedding providers — OpenAI, Ollama, custom, local ONNX
├── local_embed.py Local ONNX embedding engine — HuggingFace model download
└── cli.py CLI — serve, ingest, search, embed, stats, check
```
## AI-Friendly Docs
These files are optimized for AI agents to consume:
| File | Purpose |
|------|---------|
| [`llms.txt`](llms.txt) | Quick overview — what it does, tools, config |
| [`llms-full.txt`](llms-full.txt) | Complete reference in one file |
| [`llms-install.md`](llms-install.md) | Step-by-step installation guide |
## Development
```bash
git clone https://github.com/nicholasglazer/gnosis-mcp.git
cd gnosis-mcp
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
pytest # 240+ tests, no database needed
ruff check src/ tests/
```
All tests run without a database. Keep it that way.
Good first contributions: new embedding providers, export formats, ingestion for RST/HTML/PDF (via optional extras). Open an issue first for larger changes.
## Sponsors
If Gnosis MCP saves you time, consider [sponsoring the project](https://github.com/sponsors/nicholasglazer).
## License
[MIT](LICENSE)
| text/markdown | null | Nicholas Glazer <info@nicgl.com> | null | null | null | ai, claude, cursor, documentation, knowledge-base, llm, mcp, mcp-server, model-context-protocol, rag, search, sqlite, vector-search, windsurf | [
"Development Status :: 4 - Beta",
"Framework :: AsyncIO",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Database",
"Topic :: Documentation",
"Typing :: Typed"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"aiosqlite>=0.20",
"mcp>=1.20",
"pytest-asyncio>=0.24; extra == \"dev\"",
"pytest>=8; extra == \"dev\"",
"ruff>=0.8; extra == \"dev\"",
"numpy>=1.24; extra == \"embeddings\"",
"onnxruntime>=1.17; extra == \"embeddings\"",
"sqlite-vec>=0.1.1; extra == \"embeddings\"",
"tokenizers>=0.15; extra == \"embeddings\"",
"docutils>=0.20; extra == \"formats\"",
"pypdf>=4.0; extra == \"formats\"",
"pypdf>=4.0; extra == \"pdf\"",
"asyncpg>=0.29; extra == \"postgres\"",
"docutils>=0.20; extra == \"rst\""
] | [] | [] | [] | [
"Homepage, https://github.com/nicholasglazer/gnosis-mcp",
"Repository, https://github.com/nicholasglazer/gnosis-mcp",
"Issues, https://github.com/nicholasglazer/gnosis-mcp/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T14:00:26.684476 | gnosis_mcp-0.7.13.tar.gz | 293,858 | 2e/40/2f8ad7746c592ff09fbd0d24279b7ede67d833dc09d6e5aae7488c1f20f9/gnosis_mcp-0.7.13.tar.gz | source | sdist | null | false | da94189842228d89e62d5110cda26a5c | fe8d826c1eb9406999bfa0fe9f5da3dede08f2b28088808cc8c8d6dd627a5aa7 | 2e402f8ad7746c592ff09fbd0d24279b7ede67d833dc09d6e5aae7488c1f20f9 | MIT | [
"LICENSE"
] | 221 |
2.1 | aws-cdk.lambda-layer-kubectl-v33 | 2.0.1 | A Lambda Layer that contains kubectl v1.33 | # Lambda Layer with KubeCtl v1.33
<!--BEGIN STABILITY BANNER-->---
---
<!--END STABILITY BANNER-->
This module exports a single class called `KubectlV33Layer` which is a `lambda.LayerVersion` that
bundles the [`kubectl`](https://kubernetes.io/docs/reference/kubectl/kubectl/) and the
[`helm`](https://helm.sh/) command line.
> * Helm Version: 3.18.0
> * Kubectl Version: 1.33.0
Usage:
```python
# KubectlLayer bundles the 'kubectl' and 'helm' command lines
from aws_cdk.lambda_layer_kubectl_v33 import KubectlV33Layer
import aws_cdk.aws_lambda as lambda_
# fn: lambda.Function
kubectl = KubectlV33Layer(self, "KubectlLayer")
fn.add_layers(kubectl)
```
`kubectl` will be installed under `/opt/kubectl/kubectl`, and `helm` will be installed under `/opt/helm/helm`.
| text/markdown | Amazon Web Services<aws-cdk-dev@amazon.com> | null | null | null | Apache-2.0 | null | [
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: JavaScript",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Typing :: Typed",
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved"
] | [] | https://github.com/cdklabs/awscdk-asset-kubectl#readme | null | ~=3.9 | [] | [] | [] | [
"aws-cdk-lib<3.0.0,>=2.94.0",
"constructs<11.0.0,>=10.0.5",
"jsii<2.0.0,>=1.126.0",
"publication>=0.0.3",
"typeguard==2.13.3"
] | [] | [] | [] | [
"Source, https://github.com/cdklabs/awscdk-asset-kubectl.git"
] | twine/6.1.0 CPython/3.14.2 | 2026-02-20T14:00:22.037623 | aws_cdk_lambda_layer_kubectl_v33-2.0.1.tar.gz | 35,282,246 | 1b/3a/0e6b4afa01315bef5b85bb9936a906ece474811d00046c57156afd3e0e3d/aws_cdk_lambda_layer_kubectl_v33-2.0.1.tar.gz | source | sdist | null | false | 79378a597fe6ac4b2649208ebe0318be | a37bec0e4a86e96eb7ee4782b95d76025ffc5d8a5c1bb35d237e3120540a8ec5 | 1b3a0e6b4afa01315bef5b85bb9936a906ece474811d00046c57156afd3e0e3d | null | [] | 0 |
2.4 | gale-shapley-algorithm | 1.4.1 | A Python implementation of the celebrated Gale-Shapley Algorithm. | # gale-shapley-algorithm
A Python implementation of the celebrated Gale-Shapley (a.k.a. the Deferred Acceptance) Algorithm.
Time complexity is O(n^2), space complexity is O(n).
[](https://github.com/oedokumaci/gale-shapley-algorithm/actions/workflows/ci.yml)
[](https://oedokumaci.github.io/gale-shapley-algorithm)
[](https://hub.docker.com/r/oedokumaci/gale-shapley-algorithm)
[](https://pypi.org/project/gale-shapley-algorithm/)
[](https://pypi.org/project/gale-shapley-algorithm/)
[](https://github.com/astral-sh/ruff)
[](https://github.com/astral-sh/uv)
[](https://opensource.org/licenses/MIT)
## GUI with Docker
The easiest way to try the algorithm is with the interactive web GUI:
```bash
docker pull oedokumaci/gale-shapley-algorithm
docker run --rm -p 8000:8000 oedokumaci/gale-shapley-algorithm
```
Then open [http://localhost:8000](http://localhost:8000) in your browser.
Or build locally for development:
```bash
docker build -t gale-shapley-algorithm .
docker run --rm -p 8000:8000 gale-shapley-algorithm
```
The GUI lets you:
- **Add and remove people** on each side (proposers and responders)
- **Set preferences** by drag-and-drop reordering
- **Randomize** all preferences with one click
- **Run the matching** and see results in a table with stability info
- **Animate step-by-step** to watch proposals, rejections, and tentative matches unfold round by round in an SVG visualization
- **Upload images** for each person to personalize the visualization
- Toggle **dark/light mode**
## Installation
```bash
pip install gale-shapley-algorithm
```
With CLI support:
```bash
pip install "gale-shapley-algorithm[cli]"
```
## Quick Start
### As a Library
```python
import gale_shapley_algorithm as gsa
result = gsa.create_matching(
proposer_preferences={
"alice": ["bob", "charlie"],
"dave": ["charlie", "bob"],
},
responder_preferences={
"bob": ["alice", "dave"],
"charlie": ["dave", "alice"],
},
)
print(result.matches) # {'alice': 'bob', 'dave': 'charlie'}
```
### As a CLI
The CLI uses interactive prompts -- no config files needed:
```bash
# Interactive mode: enter names and rank preferences
uvx --from "gale-shapley-algorithm[cli]" python -m gale_shapley_algorithm
# Random mode: auto-generate names and preferences
uvx --from "gale-shapley-algorithm[cli]" python -m gale_shapley_algorithm --random
# Swap proposers and responders
uvx --from "gale-shapley-algorithm[cli]" python -m gale_shapley_algorithm --swap-sides
```
**Interactive mode example:**
```
$ python -m gale_shapley_algorithm
Gale-Shapley Algorithm
Enter proposer side name [Proposers]: Men
Enter responder side name [Responders]: Women
Enter names for Men (comma-separated): Will, Hampton
Enter names for Women (comma-separated): April, Summer
Ranking preferences for Men...
Available for Will:
1. April
2. Summer
Enter ranking for Will (e.g. 1,2): 1,2
-> Will: April > Summer
Available for Hampton:
1. April
2. Summer
Enter ranking for Hampton (e.g. 1,2): 2,1
-> Hampton: Summer > April
Ranking preferences for Women...
...
┌──────── Matching Result ────────┐
│ Men │ Women │
├─────────┼───────────────────────┤
│ Will │ April │
│ Hampton │ Summer │
└─────────┴───────────────────────┘
Completed in 1 round. Stable: Yes
```
**Random mode example:**
```
$ python -m gale_shapley_algorithm --random
Gale-Shapley Algorithm
Enter proposer side name [Proposers]: Cats
Enter responder side name [Responders]: Dogs
Number of Cats [3]: 3
Number of Dogs [3]: 3
... (random preferences generated and displayed) ...
Completed in 2 rounds. Stable: Yes
```
## Development
This project is managed with [uv](https://github.com/astral-sh/uv) and uses [taskipy](https://github.com/taskipy/taskipy) for task running.
```bash
git clone https://github.com/oedokumaci/gale-shapley-algorithm
cd gale-shapley-algorithm
uvx --from taskipy task setup # Install dependencies
uvx --from taskipy task run # Run the application
uvx --from taskipy task fix # Auto-format + lint fix
uvx --from taskipy task ci # Run all CI checks
uvx --from taskipy task test # Run tests
uvx --from taskipy task docs # Serve docs locally
```
Install pre-commit hooks:
```bash
uv run pre-commit install
```
## Documentation
Full documentation is available at [oedokumaci.github.io/gale-shapley-algorithm](https://oedokumaci.github.io/gale-shapley-algorithm).
## License
[MIT](LICENSE)
| text/markdown | null | oedokumaci <oral.ersoy.dokumaci@gmail.com> | null | null | MIT | algorithm, deferred-acceptance, gale-shapley-algorithm, matching, stable-matching | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Education",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Scientific/Engineering :: Mathematics",
"Typing :: Typed"
] | [] | null | null | >=3.12 | [] | [] | [] | [
"rich>=13.0; extra == \"cli\"",
"typer>=0.9.0; extra == \"cli\"",
"pre-commit>=3.0; extra == \"dev\"",
"rich>=13.0; extra == \"dev\"",
"ruff>=0.9; extra == \"dev\"",
"typer>=0.9.0; extra == \"dev\"",
"fastapi>=0.115; extra == \"gui\"",
"uvicorn[standard]>=0.30; extra == \"gui\""
] | [] | [] | [] | [
"Homepage, https://oedokumaci.github.io/gale-shapley-algorithm",
"Documentation, https://oedokumaci.github.io/gale-shapley-algorithm",
"Changelog, https://oedokumaci.github.io/gale-shapley-algorithm/changelog",
"Repository, https://github.com/oedokumaci/gale-shapley-algorithm",
"Issues, https://github.com/oedokumaci/gale-shapley-algorithm/issues",
"Discussions, https://github.com/oedokumaci/gale-shapley-algorithm/discussions"
] | 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-20T13:59:45.513977 | gale_shapley_algorithm-1.4.1-py3-none-any.whl | 19,667 | 88/86/7d8314fa687e9fb47f8139fbc615323d593c68fe58d11ff42f9fd1fd6ab0/gale_shapley_algorithm-1.4.1-py3-none-any.whl | py3 | bdist_wheel | null | false | 4676a28786c4d21cacc4a5efb599ef6c | 00528d26c1c1d630a31811bf4fff6a2acb407498e49fcf0fdbf1e80b503ae01b | 88867d8314fa687e9fb47f8139fbc615323d593c68fe58d11ff42f9fd1fd6ab0 | null | [
"LICENSE"
] | 220 |
2.4 | gitflow-manager | 1.1.4 | This package contains the Anacision Git Manager. | # Anacision Gitflow Manager
## Description
The gitflow manager is a tool that helps maintaining clean versioning and documentation in code projects.
By using the gitflow manager one can make sure to stick to the
[GitFlow](https://nvie.com/posts/a-successful-git-branching-model) rules. Furthermore, it helps maintain a good
changelog and documentation.
Whenever you want to start a new branch or merging it back to dev/main run the `gfm` command.
It uses a dialog to define the type of new branch (feature, bugfix, hotfix, release) or merge option as well as setting
the required changelog messages.
It then automatically updates version numbers, checks out corresponding branches and commits/merges according to the
GitFlow.
Changes are also pushed to the Git Host via ssh or https and for protected branches merge requests are initialized.
Currently, the gitflow manager supports Gitlab and Bitbucket as hosting platforms.
### Versioning
- Utilize the gitflow manager in projects to make sure that you easily stick to these rules:
- Versions are defined in the format *Major.Minor.Hotfix*. New versions are created when opening the hotfix or release
branch.
- The hotfix branch is only allowed to be started from main branch, to increase the Hotfix version digit only and to
be merged into main (+ dev thereafter).
- The release branch is only allowed to be started from dev, to increase the minor or major version digit and to be
merged into main (+ dev thereafter). In case of a new major version, the minor and hotfix digit is reset to 0. In case
of a new minor version, the hotfix digit is reset to 0.
- The bugfix and feature branches are only allowed to be started from dev, increase no version number and are merged
back to dev.
- All new branches need a description in the change log, which has separate "Added", "Changed" and "Fixed" sections.
### Supported branches with gitflow manager
- **main**: Permanent, stable, (normally) protected branch used for deployment. Each commit has a new version. Merge
requests only come from release or hotfix branch.
- **dev**: Permanent development branch. Gets merge requests from feature, hotfix and release branch.
- **release/vX.X.X**: Release branch. Branched off from dev branch with new minor or major version. When the branch is
finished, it is merged into main and dev branch. Intermediate merges into dev are allowed, too. Merges from dev into
release branch are not allowed.
- **feature/xxxxxx**: For features to be developed. Branched off from dev branch and will be merged back into dev after
finishing feature.
- **bugfix/xxxxxx**: For bugs to be fixed. Branched off from dev branch and will be merged back into dev after
finishing the fix.
- **hotfix/vX.X.X**: Hotfix branch for fixes from deployed code. Branched off from main branch with new hotfix
version. When done, is merged into main and dev branch.
### Tagging
- Currently, tagging is not done automatically. You can configure yourself a CI pipeline, that does the job for you.
## Getting started
### Installation
1. Install gitflow manager with pip: `pip install gitflow-manager`
2. Restart terminal
### Usage
- When using the first time, run `gfm --init` in the root of the project.
- Subsequently, just type `gfm` each time you need to branch or merge (or add change log information), and follow the
dialog
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"gitpython>=3.1.24",
"pystache>=0.6.0",
"pyyaml>=6.0.2",
"requests>=2.27.1",
"tomlkit>=0.13.3"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.10.19 | 2026-02-20T13:59:35.124854 | gitflow_manager-1.1.4.tar.gz | 19,825 | ce/f7/016aebb5bdb2346d84a60bad7319767485405324bc85a4ebdb8c40b79076/gitflow_manager-1.1.4.tar.gz | source | sdist | null | false | 1b5122c509ea2c8b4ec46b4d7691389e | 6e3f8ba6d7eee2988e724b0dc1537f194d618dc50196714103a51038e4f5142d | cef7016aebb5bdb2346d84a60bad7319767485405324bc85a4ebdb8c40b79076 | null | [] | 216 |
2.4 | pytest-language-server | 0.20.0 | A blazingly fast Language Server Protocol implementation for pytest | # pytest-language-server 🔥
[](https://github.com/bellini666/pytest-language-server/actions/workflows/ci.yml)
[](https://github.com/bellini666/pytest-language-server/actions/workflows/security.yml)
[](https://badge.fury.io/py/pytest-language-server)
[](https://pepy.tech/project/pytest-language-server)
[](https://crates.io/crates/pytest-language-server)
[](https://opensource.org/licenses/MIT)
[](https://pypi.org/project/pytest-language-server/)
A blazingly fast Language Server Protocol (LSP) implementation for pytest, built with Rust, with
full support for fixture discovery, go to definition, code completion, find references, hover
documentation, diagnostics, and more!
[](demo/demo.mp4)
## Table of Contents
- [Features](#features)
- [Go to Definition](#-go-to-definition)
- [Go to Implementation](#-go-to-implementation)
- [Call Hierarchy](#-call-hierarchy)
- [Code Completion](#-code-completion)
- [Find References](#-find-references)
- [Hover Documentation](#-hover-documentation)
- [Document Symbols](#-document-symbols)
- [Workspace Symbols](#-workspace-symbols)
- [Code Lens](#-code-lens)
- [Code Actions (Quick Fixes)](#-code-actions-quick-fixes)
- [Diagnostics & Quick Fixes](#️-diagnostics--quick-fixes)
- [Performance](#️-performance)
- [Installation](#installation)
- [Setup](#setup)
- [Neovim](#neovim)
- [Zed](#zed)
- [VS Code](#vs-code)
- [IntelliJ IDEA / PyCharm](#intellij-idea--pycharm)
- [Emacs](#emacs)
- [Other Editors](#other-editors)
- [Configuration](#configuration)
- [CLI Commands](#cli-commands)
- [Supported Fixture Patterns](#supported-fixture-patterns)
- [Fixture Priority Rules](#fixture-priority-rules)
- [Supported Third-Party Fixtures](#supported-third-party-fixtures)
- [Architecture](#architecture)
- [Development](#development)
- [Security](#security)
- [Contributing](#contributing)
- [License](#license)
- [Acknowledgments](#acknowledgments)
## Features
> **Built with AI, maintained with care** 🤖
>
> This project was built with the help of AI coding agents, but carefully reviewed to ensure
> correctness, reliability, security and performance. If you find any issues, please open an issue
> or submit a pull request!
### 🎯 Go to Definition
Jump directly to fixture definitions from anywhere they're used:
- Local fixtures in the same file
- Fixtures in `conftest.py` files
- Third-party fixtures from pytest plugins (pytest-mock, pytest-asyncio, etc.)
- Respects pytest's fixture shadowing/priority rules
### 🔧 Go to Implementation
Jump to the yield statement in generator fixtures:
- **Generator fixtures**: Navigates to where `yield` produces the fixture value
- **Teardown navigation**: Useful for reviewing fixture cleanup logic
- **Non-generator fallback**: Falls back to definition for simple return-based fixtures
Example:
```python
@pytest.fixture
def database():
conn = connect()
yield conn # <-- Go to Implementation jumps here
conn.close() # Teardown code after yield
```
### 🔗 Call Hierarchy
Explore fixture dependencies with Call Hierarchy support:
- **Incoming Calls**: See which tests and fixtures depend on a fixture
- **Outgoing Calls**: See which fixtures a fixture depends on
- Works with your editor's "Show Call Hierarchy" command
- Helps understand complex fixture dependency chains
```python
@pytest.fixture
def database(): # <-- Call Hierarchy shows:
... # Incoming: test_query, test_insert (tests using this)
# Outgoing: connection (fixtures this depends on)
```
### ✨ Code Completion
Smart auto-completion for pytest fixtures:
- **Context-aware**: Only triggers inside test functions and fixture functions
- **Hierarchy-respecting**: Suggests fixtures based on pytest's priority rules (same file > conftest.py > third-party)
- **Rich information**: Shows fixture source file and docstring
- **No duplicates**: Automatically filters out shadowed fixtures
- **Works everywhere**: Completions available in both function parameters and function bodies
- Supports both sync and async functions
### 🔍 Find References
Find all usages of a fixture across your entire test suite:
- Works from fixture definitions or usage sites
- Character-position aware (distinguishes between fixture name and parameters)
- Shows references in all test files
- Correctly handles fixture overriding and hierarchies
- **LSP spec compliant**: Always includes the current position in results
### 📚 Hover Documentation
View fixture information on hover:
- Fixture signature
- Source file location
- Docstring (with proper formatting and dedenting)
- Markdown support in docstrings
### 📑 Document Symbols
Navigate fixtures within a file using the document outline:
- **File outline view**: See all fixtures defined in the current file (Cmd+Shift+O / Ctrl+Shift+O)
- **Breadcrumb navigation**: Shows fixture hierarchy in editor breadcrumbs
- **Return type display**: Shows fixture return types when available
- **Sorted by position**: Fixtures appear in definition order
### 🔎 Workspace Symbols
Search for fixtures across your entire workspace:
- **Global search**: Find any fixture by name (Cmd+T / Ctrl+T)
- **Fuzzy matching**: Case-insensitive substring search
- **File context**: Shows which file each fixture is defined in
- **Fast lookup**: Instant results from in-memory fixture database
### 🔢 Code Lens
See fixture usage counts directly in your editor:
- **Usage count**: Shows "N usages" above each fixture definition
- **Click to navigate**: Clicking the lens shows all references (find-references integration)
- **Real-time updates**: Counts update as you add/remove fixture usages
- **Local fixtures only**: Only shows lenses for project fixtures, not third-party
### 🏷️ Inlay Hints
See fixture return types inline without leaving your code:
- **Type annotations**: Shows return types next to fixture parameters (e.g., `db: Database`)
- **Explicit types only**: Only displays hints when fixtures have explicit return type annotations
- **Generator support**: Extracts yielded type from `Generator[T, None, None]` annotations
- **Non-intrusive**: Hints appear as subtle inline decorations that don't modify your code
Example:
```python
# With a fixture defined as:
@pytest.fixture
def database() -> Database:
return Database()
# In your test, you'll see:
def test_example(database): # Shows ": Database" after "database"
pass
```
### 💡 Code Actions (Quick Fixes)
One-click fixes for common pytest issues:
- **Add missing fixture parameters**: Automatically add undeclared fixtures to function signatures
- **Smart insertion**: Handles both empty and existing parameter lists
- **Editor integration**: Works with any LSP-compatible editor's quick fix menu
- **LSP compliant**: Full support for `CodeActionKind::QUICKFIX`
### ⚠️ Diagnostics & Quick Fixes
Detect and fix common pytest fixture issues with intelligent code actions:
**Fixture Scope Validation:**
- Detects when a broader-scoped fixture depends on a narrower-scoped fixture
- Example: A `session`-scoped fixture cannot depend on a `function`-scoped fixture
- Warnings show both the fixture's scope and its dependency's scope
- Prevents hard-to-debug test failures from scope violations
**Circular Dependency Detection:**
- Detects when fixtures form circular dependency chains (A → B → C → A)
- Reports the full cycle path for easy debugging
- Works across files (conftest.py hierarchies)
Scope mismatch example:
```python
# ⚠️ Scope mismatch! session-scoped fixture depends on function-scoped
@pytest.fixture(scope="session")
def shared_db(temp_dir): # temp_dir is function-scoped
return Database(temp_dir)
@pytest.fixture # Default is function scope
def temp_dir(tmp_path):
return tmp_path / "test"
```
**Undeclared Fixture Detection:**
- Detects when fixtures are used in function bodies but not declared as parameters
- **Line-aware scoping**: Correctly handles local variables assigned later in the function
- **Hierarchy-aware**: Only reports fixtures that are actually available in the current file's scope
- **Works in tests and fixtures**: Detects undeclared usage in both test functions and fixture functions
- Excludes built-in names (`self`, `request`) and actual local variables
**One-Click Quick Fixes:**
- **Code actions** to automatically add missing fixture parameters
- Intelligent parameter insertion (handles both empty and existing parameter lists)
- Works with both single-line and multi-line function signatures
- Triggered directly from diagnostic warnings
Example:
```python
@pytest.fixture
def user_db():
return Database()
def test_user(user_db): # ✅ user_db properly declared
user = user_db.get_user(1)
assert user.name == "Alice"
def test_broken(): # ⚠️ Warning: 'user_db' used but not declared
user = user_db.get_user(1) # 💡 Quick fix: Add 'user_db' fixture parameter
assert user.name == "Alice"
```
**How to use quick fixes:**
1. Place cursor on the warning squiggle
2. Trigger code actions menu (usually Cmd+. or Ctrl+. in most editors)
3. Select "Add 'fixture_name' fixture parameter"
4. The parameter is automatically added to your function signature
### ⚡️ Performance
Built with Rust for maximum performance:
- Fast workspace scanning with concurrent file processing
- Efficient AST parsing using rustpython-parser
- Lock-free data structures with DashMap
- Minimal memory footprint
## Installation
Choose your preferred installation method:
### 📦 PyPI (Recommended)
The easiest way to install for Python projects:
```bash
# Using uv (recommended)
uv tool install pytest-language-server
# Or with pip
pip install pytest-language-server
# Or with pipx (isolated environment)
pipx install pytest-language-server
```
### 🍺 Homebrew (macOS/Linux)
Install via Homebrew for system-wide availability:
```bash
brew install bellini666/tap/pytest-language-server
```
To add the tap first:
```bash
brew tap bellini666/tap https://github.com/bellini666/pytest-language-server
brew install pytest-language-server
```
### 🦀 Cargo (Rust)
Install from crates.io if you have Rust installed:
```bash
cargo install pytest-language-server
```
### 📥 Pre-built Binaries
Download pre-built binaries from the [GitHub Releases](https://github.com/bellini666/pytest-language-server/releases) page.
Available for:
- **Linux**: x86_64, aarch64, armv7 (glibc and musl)
- **macOS**: Intel and Apple Silicon
- **Windows**: x64 and x86
### 🔨 From Source
Build from source for development or customization:
```bash
git clone https://github.com/bellini666/pytest-language-server
cd pytest-language-server
cargo build --release
```
The binary will be at `target/release/pytest-language-server`.
## Setup
### Neovim
Add this to your config:
```lua
vim.lsp.config('pytest_lsp', {
cmd = { 'pytest-language-server' },
filetypes = { 'python' },
root_markers = { 'pyproject.toml', 'setup.py', 'setup.cfg', 'pytest.ini', '.git' },
})
vim.lsp.enable('pytest_lsp')
```
### Zed
Install from the [Zed Extensions Marketplace](https://zed.dev/extensions/pytest-language-server):
1. Open Zed
2. Open the command palette (Cmd+Shift+P / Ctrl+Shift+P)
3. Search for "zed: extensions"
4. Search for "pytest Language Server"
5. Click "Install"
The extension downloads platform-specific binaries from GitHub Releases. If you prefer to use your own installation (via pip, cargo, or brew), place `pytest-language-server` in your PATH.
After installing the extension, you need to enable the language server for Python files. Add the following to your Zed `settings.json`:
```json
{
"languages": {
"Python": {
"language_servers": ["pyright", "pytest-language-server", "..."]
}
}
}
```
### VS Code
**The extension includes pre-built binaries - no separate installation required!**
Install from the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=bellini666.pytest-language-server):
1. Open VS Code
2. Go to Extensions (Cmd+Shift+X / Ctrl+Shift+X)
3. Search for "pytest Language Server"
4. Click "Install"
Works out of the box with zero configuration!
### IntelliJ IDEA / PyCharm
**The plugin includes pre-built binaries - no separate installation required!**
Install from the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/29056-pytest-language-server):
1. Open PyCharm or IntelliJ IDEA
2. Go to Settings/Preferences → Plugins
3. Search for "pytest Language Server"
4. Click "Install"
Requires PyCharm 2024.2+ or IntelliJ IDEA 2024.2+ with Python plugin.
### Emacs
Add this to your config:
```elisp
(use-package eglot
:config
(add-to-list 'eglot-server-programs
'((python-mode python-ts-mode) . ("pytest-language-server"))))
```
### Other Editors
Any editor with LSP support can use pytest-language-server. Configure it to run the `pytest-language-server` command.
## Configuration
### pyproject.toml
Configure pytest-language-server via your project's `pyproject.toml`:
```toml
[tool.pytest-language-server]
# Glob patterns for files/directories to exclude from scanning
exclude = ["build/**", "dist/**", ".tox/**"]
# Disable specific diagnostics
# Valid codes: "undeclared-fixture", "scope-mismatch", "circular-dependency"
disabled_diagnostics = ["undeclared-fixture"]
# Additional directories to scan for fixtures (planned feature)
fixture_paths = ["fixtures/", "shared/fixtures/"]
# Third-party plugins to skip when scanning venv (planned feature)
skip_plugins = ["pytest-xdist"]
```
**Available Options:**
| Option | Type | Description |
|--------|------|-------------|
| `exclude` | `string[]` | Glob patterns for paths to exclude from workspace scanning |
| `disabled_diagnostics` | `string[]` | Diagnostic codes to suppress |
| `fixture_paths` | `string[]` | Additional fixture directories *(planned)* |
| `skip_plugins` | `string[]` | Third-party plugins to skip *(planned)* |
**Diagnostic Codes:**
- `undeclared-fixture` - Fixture used in function body but not declared as parameter
- `scope-mismatch` - Broader-scoped fixture depends on narrower-scoped fixture
- `circular-dependency` - Circular fixture dependency detected
### Logging
Control log verbosity with the `RUST_LOG` environment variable:
```bash
# Minimal logging (default)
RUST_LOG=warn pytest-language-server
# Info level
RUST_LOG=info pytest-language-server
# Debug level (verbose)
RUST_LOG=debug pytest-language-server
# Trace level (very verbose)
RUST_LOG=trace pytest-language-server
```
Logs are written to stderr, so they won't interfere with LSP communication.
### Virtual Environment Detection
The server automatically detects your Python virtual environment:
1. Checks for `.venv/`, `venv/`, or `env/` in your project root
2. Falls back to `$VIRTUAL_ENV` environment variable
3. Scans third-party pytest plugins for fixtures
### Code Actions / Quick Fixes
Code actions are automatically available on diagnostic warnings. If code actions don't appear in your editor:
1. **Check LSP capabilities**: Ensure your editor supports code actions (most modern editors do)
2. **Enable debug logging**: Use `RUST_LOG=info` to see if actions are being created
3. **Verify diagnostics**: Code actions only appear where there are warnings
4. **Trigger manually**: Use your editor's code action keybinding (Cmd+. / Ctrl+.)
## CLI Commands
In addition to the LSP server mode, pytest-language-server provides useful command-line tools:
### Fixtures List
View all fixtures in your test suite with a hierarchical tree view:
```bash
# List all fixtures
pytest-language-server fixtures list tests/
# Skip unused fixtures
pytest-language-server fixtures list tests/ --skip-unused
# Show only unused fixtures
pytest-language-server fixtures list tests/ --only-unused
```
The output includes:
- **Color-coded display**: Files in cyan, directories in blue, used fixtures in green, unused in gray
- **Usage statistics**: Shows how many times each fixture is used
- **Smart filtering**: Hides files and directories with no matching fixtures
- **Hierarchical structure**: Visualizes fixture organization across conftest.py files
Example output:
```
Fixtures tree for: /path/to/tests
conftest.py (7 fixtures)
├── another_fixture (used 2 times)
├── cli_runner (used 7 times)
├── database (used 6 times)
├── generator_fixture (used 1 time)
├── iterator_fixture (unused)
├── sample_fixture (used 7 times)
└── shared_resource (used 5 times)
subdir/
└── conftest.py (4 fixtures)
├── cli_runner (used 7 times)
├── database (used 6 times)
├── local_fixture (used 4 times)
└── sample_fixture (used 7 times)
```
This command is useful for:
- **Auditing fixture usage** across your test suite
- **Finding unused fixtures** that can be removed
- **Understanding fixture organization** and hierarchy
- **Documentation** - visualizing available fixtures for developers
### Fixtures Unused
Find unused fixtures in your test suite, with CI-friendly exit codes:
```bash
# List unused fixtures (text format)
pytest-language-server fixtures unused tests/
# JSON output for programmatic use
pytest-language-server fixtures unused tests/ --format json
```
**Exit codes:**
- `0`: All fixtures are used
- `1`: Unused fixtures found
Example text output:
```
Found 4 unused fixture(s):
• iterator_fixture in conftest.py
• auto_cleanup in utils/conftest.py
• temp_dir in utils/conftest.py
• temp_file in utils/conftest.py
Tip: Remove unused fixtures or add tests that use them.
```
Example JSON output:
```json
[
{"file": "conftest.py", "fixture": "iterator_fixture"},
{"file": "utils/conftest.py", "fixture": "auto_cleanup"},
{"file": "utils/conftest.py", "fixture": "temp_dir"},
{"file": "utils/conftest.py", "fixture": "temp_file"}
]
```
This command is ideal for:
- **CI/CD pipelines** - fail builds when unused fixtures accumulate
- **Code cleanup** - identify dead code in test infrastructure
- **Linting** - integrate with pre-commit hooks or quality gates
## Supported Fixture Patterns
### Decorator Style
```python
@pytest.fixture
def my_fixture():
"""Fixture docstring."""
return 42
```
### Assignment Style (pytest-mock)
```python
mocker = pytest.fixture()(_mocker)
```
### Async Fixtures
```python
@pytest.fixture
async def async_fixture():
return await some_async_operation()
```
### Fixture Dependencies
```python
@pytest.fixture
def fixture_a():
return "a"
@pytest.fixture
def fixture_b(fixture_a): # Go to definition works on fixture_a
return fixture_a + "b"
```
### @pytest.mark.usefixtures
```python
@pytest.mark.usefixtures("database", "cache")
class TestWithFixtures:
def test_something(self):
pass # database and cache are available
```
### @pytest.mark.parametrize with indirect
```python
@pytest.fixture
def user(request):
return User(name=request.param)
# All parameters treated as fixtures
@pytest.mark.parametrize("user", ["alice", "bob"], indirect=True)
def test_user(user):
pass
# Selective indirect fixtures
@pytest.mark.parametrize("user,value", [("alice", 1)], indirect=["user"])
def test_user_value(user, value):
pass
```
### Imported Fixtures (`from ... import *`)
```python
# conftest.py
from .pytest_fixtures import * # Fixtures from pytest_fixtures.py are available
```
### `pytest_plugins` Variable
```python
# conftest.py
pytest_plugins = ["myapp.fixtures", "other.fixtures"]
# Also supports single strings, tuples, and annotated assignments:
# pytest_plugins = "myapp.fixtures"
# pytest_plugins = ("myapp.fixtures",)
# pytest_plugins: list[str] = ["myapp.fixtures"]
```
Fixtures declared in `pytest_plugins` modules are automatically discovered in `conftest.py`, test files, and plugin entry point modules. Only static string literals are supported — dynamic values are ignored.
## Fixture Priority Rules
pytest-language-server correctly implements pytest's fixture shadowing rules:
1. **Same file**: Fixtures defined in the same file have highest priority
2. **Closest conftest.py**: Searches parent directories for conftest.py files
3. **Virtual environment**: Third-party plugin fixtures
### Fixture Overriding
The LSP correctly handles complex fixture overriding scenarios:
```python
# conftest.py (parent)
@pytest.fixture
def cli_runner():
return "parent runner"
# tests/conftest.py (child)
@pytest.fixture
def cli_runner(cli_runner): # Overrides parent
return cli_runner # Uses parent
# tests/test_example.py
def test_example(cli_runner): # Uses child
pass
```
When using find-references:
- Clicking on the **function name** `def cli_runner(...)` shows references to the child fixture
- Clicking on the **parameter** `cli_runner(cli_runner)` shows references to the parent fixture
- Character-position aware to distinguish between the two
## Supported Third-Party Fixtures
Automatically discovers fixtures from **50+ popular pytest plugins**, including:
- **Testing frameworks**: pytest-mock, pytest-asyncio, pytest-bdd, pytest-cases
- **Web frameworks**: pytest-flask, pytest-django, pytest-aiohttp, pytest-tornado, pytest-sanic, pytest-fastapi
- **HTTP clients**: pytest-httpx
- **Databases**: pytest-postgresql, pytest-mongodb, pytest-redis, pytest-mysql, pytest-elasticsearch
- **Infrastructure**: pytest-docker, pytest-kubernetes, pytest-rabbitmq, pytest-celery
- **Browser testing**: pytest-selenium, pytest-playwright, pytest-splinter
- **Performance**: pytest-benchmark, pytest-timeout
- **Test data**: pytest-factoryboy, pytest-freezegun, pytest-mimesis
- And many more...
The server automatically scans your virtual environment for any pytest plugin and makes their fixtures available.
## Architecture
- **Language**: Rust 🦀
- **LSP Framework**: tower-lsp-server
- **Parser**: rustpython-parser
- **Concurrency**: tokio async runtime
- **Data Structures**: DashMap for lock-free concurrent access
## Development
### Prerequisites
- Rust 1.85+ (2021 edition)
- Python 3.10+ (for testing)
### Building
```bash
cargo build --release
```
### Running Tests
```bash
cargo test
```
### Logging During Development
```bash
RUST_LOG=debug cargo run
```
## Security
Security is a priority. This project includes:
- Automated dependency vulnerability scanning (cargo-audit)
- License compliance checking (cargo-deny)
- Daily security audits in CI/CD
- Dependency review on pull requests
- Pre-commit security hooks
See [SECURITY.md](SECURITY.md) for our security policy and how to report vulnerabilities.
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
### Development Setup
1. Install pre-commit hooks:
```bash
pre-commit install
```
2. Run security checks locally:
```bash
cargo audit
cargo clippy
cargo test
```
## License
MIT License - see LICENSE file for details.
## Acknowledgments
Built with:
- [tower-lsp-server](https://github.com/tower-lsp-community/tower-lsp-server) - LSP framework
- [rustpython-parser](https://github.com/RustPython/RustPython) - Python AST parsing
- [tokio](https://tokio.rs/) - Async runtime
Special thanks to the pytest team for creating such an amazing testing framework.
---
**Made with ❤️ and Rust. Blazingly fast 🔥**
*Built with AI assistance, maintained with care.*
| text/markdown; charset=UTF-8; variant=GFM | null | Thiago Bellini Ribeiro <hackedbellini@gmail.com> | null | null | MIT | pytest, lsp, language-server, testing | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Programming Language :: Rust",
"Topic :: Software Development :: Testing",
"Topic :: Software Development :: Libraries"
] | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/bellini666/pytest-language-server",
"Issues, https://github.com/bellini666/pytest-language-server/issues",
"Repository, https://github.com/bellini666/pytest-language-server"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T13:58:29.173588 | pytest_language_server-0.20.0.tar.gz | 2,857,906 | 64/8e/a28a149e216dbdf2aa19d5753a052df9d3672efb085c1b774ed12a414346/pytest_language_server-0.20.0.tar.gz | source | sdist | null | false | 846fdf92cf2e178a4bcda4dd2f567139 | 58dfa49a8f7f40af68e1be4be468fa0a3486a55fd42a82b9e829250d766bf38c | 648ea28a149e216dbdf2aa19d5753a052df9d3672efb085c1b774ed12a414346 | null | [
"LICENSE"
] | 1,020 |
2.4 | fugue | 0.9.7 | An abstraction layer for distributed computing | # <img src="./images/logo.svg" width="200">
[](https://pypi.python.org/pypi/fugue/)
[](https://pypi.python.org/pypi/fugue/)
[](https://pypi.python.org/pypi/fugue/)
[](https://codecov.io/gh/fugue-project/fugue)
[](https://www.codacy.com/gh/fugue-project/fugue/dashboard?utm_source=github.com&utm_medium=referral&utm_content=fugue-project/fugue&utm_campaign=Badge_Grade)
[](https://pepy.tech/project/fugue)
| Tutorials | API Documentation | Chat with us on slack! |
| --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| [](https://fugue-tutorials.readthedocs.io/) | [](https://fugue.readthedocs.org) | [](http://slack.fugue.ai) |
**Fugue is a unified interface for distributed computing that lets users execute Python, Pandas, and SQL code on Spark, Dask, and Ray with minimal rewrites**.
Fugue is most commonly used for:
* **Parallelizing or scaling existing Python and Pandas code** by bringing it to Spark, Dask, or Ray with minimal rewrites.
* Using [FugueSQL](https://fugue-tutorials.readthedocs.io/tutorials/quick_look/ten_minutes_sql.html) to **define end-to-end workflows** on top of Pandas, Spark, and Dask DataFrames. FugueSQL is an enhanced SQL interface that can invoke Python code.
To see how Fugue compares to other frameworks like dbt, Arrow, Ibis, PySpark Pandas, see the [comparisons](https://fugue-tutorials.readthedocs.io/#how-does-fugue-compare-to)
## [Fugue API](https://fugue-tutorials.readthedocs.io/tutorials/quick_look/ten_minutes.html)
The Fugue API is a collection of functions that are capable of running on Pandas, Spark, Dask, and Ray. The simplest way to use Fugue is the [`transform()` function](https://fugue-tutorials.readthedocs.io/tutorials/beginner/transform.html). This lets users parallelize the execution of a single function by bringing it to Spark, Dask, or Ray. In the example below, the `map_letter_to_food()` function takes in a mapping and applies it on a column. This is just Pandas and Python so far (without Fugue).
```python
import pandas as pd
from typing import Dict
input_df = pd.DataFrame({"id":[0,1,2], "value": (["A", "B", "C"])})
map_dict = {"A": "Apple", "B": "Banana", "C": "Carrot"}
def map_letter_to_food(df: pd.DataFrame, mapping: Dict[str, str]) -> pd.DataFrame:
df["value"] = df["value"].map(mapping)
return df
```
Now, the `map_letter_to_food()` function is brought to the Spark execution engine by invoking the `transform()` function of Fugue. The output `schema` and `params` are passed to the `transform()` call. The `schema` is needed because it's a requirement for distributed frameworks. A schema of `"*"` below means all input columns are in the output.
```python
from pyspark.sql import SparkSession
from fugue import transform
spark = SparkSession.builder.getOrCreate()
sdf = spark.createDataFrame(input_df)
out = transform(sdf,
map_letter_to_food,
schema="*",
params=dict(mapping=map_dict),
)
# out is a Spark DataFrame
out.show()
```
```rst
+---+------+
| id| value|
+---+------+
| 0| Apple|
| 1|Banana|
| 2|Carrot|
+---+------+
```
<details>
<summary>PySpark equivalent of Fugue transform()</summary>
```python
from typing import Iterator, Union
from pyspark.sql.types import StructType
from pyspark.sql import DataFrame, SparkSession
spark_session = SparkSession.builder.getOrCreate()
def mapping_wrapper(dfs: Iterator[pd.DataFrame], mapping):
for df in dfs:
yield map_letter_to_food(df, mapping)
def run_map_letter_to_food(input_df: Union[DataFrame, pd.DataFrame], mapping):
# conversion
if isinstance(input_df, pd.DataFrame):
sdf = spark_session.createDataFrame(input_df.copy())
else:
sdf = input_df.copy()
schema = StructType(list(sdf.schema.fields))
return sdf.mapInPandas(lambda dfs: mapping_wrapper(dfs, mapping),
schema=schema)
result = run_map_letter_to_food(input_df, map_dict)
result.show()
```
</details>
This syntax is simpler, cleaner, and more maintainable than the PySpark equivalent. At the same time, no edits were made to the original Pandas-based function to bring it to Spark. It is still usable on Pandas DataFrames. Fugue `transform()` also supports Dask and Ray as execution engines alongside the default Pandas-based engine.
The Fugue API has a broader collection of functions that are also compatible with Spark, Dask, and Ray. For example, we can use `load()` and `save()` to create an end-to-end workflow compatible with Spark, Dask, and Ray. For the full list of functions, see the [Top Level API](https://fugue.readthedocs.io/en/latest/top_api.html)
```python
import fugue.api as fa
def run(engine=None):
with fa.engine_context(engine):
df = fa.load("/path/to/file.parquet")
out = fa.transform(df, map_letter_to_food, schema="*")
fa.save(out, "/path/to/output_file.parquet")
run() # runs on Pandas
run(engine="spark") # runs on Spark
run(engine="dask") # runs on Dask
```
All functions underneath the context will run on the specified backend. This makes it easy to toggle between local execution, and distributed execution.
## [FugueSQL](https://fugue-tutorials.readthedocs.io/tutorials/fugue_sql/index.html)
FugueSQL is a SQL-based language capable of expressing end-to-end data workflows on top of Pandas, Spark, and Dask. The `map_letter_to_food()` function above is used in the SQL expression below. This is how to use a Python-defined function along with the standard SQL `SELECT` statement.
```python
from fugue.api import fugue_sql
import json
query = """
SELECT id, value
FROM input_df
TRANSFORM USING map_letter_to_food(mapping={{mapping}}) SCHEMA *
"""
map_dict_str = json.dumps(map_dict)
# returns Pandas DataFrame
fugue_sql(query,mapping=map_dict_str)
# returns Spark DataFrame
fugue_sql(query, mapping=map_dict_str, engine="spark")
```
## Installation
Fugue can be installed through pip or conda. For example:
```bash
pip install fugue
```
In order to use Fugue SQL, it is strongly recommended to install the `sql` extra:
```bash
pip install fugue[sql]
```
It also has the following installation extras:
* **sql**: to support Fugue SQL. Without this extra, the non-SQL part still works. Before Fugue 0.9.0, this extra is included in Fugue's core dependency so you don't need to install explicitly. **But for 0,9.0+, this becomes required if you want to use Fugue SQL.**
* **spark**: to support Spark as the [ExecutionEngine](https://fugue-tutorials.readthedocs.io/tutorials/advanced/execution_engine.html).
* **dask**: to support Dask as the ExecutionEngine.
* **ray**: to support Ray as the ExecutionEngine.
* **duckdb**: to support DuckDB as the ExecutionEngine, read [details](https://fugue-tutorials.readthedocs.io/tutorials/integrations/backends/duckdb.html).
* **polars**: to support Polars DataFrames and extensions using Polars.
* **ibis**: to enable Ibis for Fugue workflows, read [details](https://fugue-tutorials.readthedocs.io/tutorials/integrations/backends/ibis.html).
* **cpp_sql_parser**: to enable the CPP antlr parser for Fugue SQL. It can be 50+ times faster than the pure Python parser. For the main Python versions and platforms, there is already pre-built binaries, but for the remaining, it needs a C++ compiler to build on the fly.
For example a common use case is:
```bash
pip install "fugue[duckdb,spark]"
```
Note if you already installed Spark or DuckDB independently, Fugue is able to automatically use them without installing the extras.
## [Getting Started](https://fugue-tutorials.readthedocs.io/)
The best way to get started with Fugue is to work through the 10 minute tutorials:
* [Fugue API in 10 minutes](https://fugue-tutorials.readthedocs.io/tutorials/quick_look/ten_minutes.html)
* [FugueSQL in 10 minutes](https://fugue-tutorials.readthedocs.io/tutorials/quick_look/ten_minutes_sql.html)
For the top level API, see:
* [Fugue Top Level API](https://fugue.readthedocs.io/en/latest/top_api.html)
The [tutorials](https://fugue-tutorials.readthedocs.io/) can also be run in an interactive notebook environment through binder or Docker:
### Using binder
[](https://mybinder.org/v2/gh/fugue-project/tutorials/master)
**Note it runs slow on binder** because the machine on binder isn't powerful enough for a distributed framework such as Spark. Parallel executions can become sequential, so some of the performance comparison examples will not give you the correct numbers.
### Using Docker
Alternatively, you should get decent performance by running this Docker image on your own machine:
```bash
docker run -p 8888:8888 fugueproject/tutorials:latest
```
## Jupyter Notebook Extension
There is an accompanying [notebook extension](https://pypi.org/project/fugue-jupyter/) for FugueSQL that lets users use the `%%fsql` cell magic. The extension also provides syntax highlighting for FugueSQL cells. It works for both classic notebook and Jupyter Lab. More details can be found in the [installation instructions](https://github.com/fugue-project/fugue-jupyter#install).
## Ecosystem
By being an abstraction layer, Fugue can be used with a lot of other open-source projects seamlessly.
Python backends:
* [Pandas](https://github.com/pandas-dev/pandas)
* [Polars](https://www.pola.rs) (DataFrames only)
* [Spark](https://github.com/apache/spark)
* [Dask](https://github.com/dask/dask)
* [Ray](http://github.com/ray-project/ray)
* [Ibis](https://github.com/ibis-project/ibis/)
FugueSQL backends:
* Pandas - FugueSQL can run on Pandas
* [Duckdb](https://github.com/duckdb/duckdb) - in-process SQL OLAP database management
* [dask-sql](https://github.com/dask-contrib/dask-sql) - SQL interface for Dask
* SparkSQL
* [BigQuery](https://fugue-tutorials.readthedocs.io/tutorials/integrations/warehouses/bigquery.html)
* Trino
Fugue is available as a backend or can integrate with the following projects:
* [WhyLogs](https://whylogs.readthedocs.io/en/latest/examples/integrations/Fugue_Profiling.html?highlight=fugue) - data profiling
* [PyCaret](https://fugue-tutorials.readthedocs.io/tutorials/integrations/ecosystem/pycaret.html) - low code machine learning
* [Nixtla](https://fugue-tutorials.readthedocs.io/tutorials/integrations/ecosystem/nixtla.html) - timeseries modelling
* [Prefect](https://fugue-tutorials.readthedocs.io/tutorials/integrations/ecosystem/prefect.html) - workflow orchestration
* [Pandera](https://fugue-tutorials.readthedocs.io/tutorials/integrations/ecosystem/pandera.html) - data validation
* [Datacompy (by Capital One)](https://fugue-tutorials.readthedocs.io/tutorials/integrations/ecosystem/datacompy.html) - comparing DataFrames
Registered 3rd party extensions (majorly for Fugue SQL) include:
* [Pandas plot](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.html) - visualize data using matplotlib or plotly
* [Seaborn](https://seaborn.pydata.org/api.html) - visualize data using seaborn
* [WhyLogs](https://whylogs.readthedocs.io/en/latest/examples/integrations/Fugue_Profiling.html?highlight=fugue) - visualize data profiling
* [Vizzu](https://github.com/vizzuhq/ipyvizzu) - visualize data using ipyvizzu
## Community and Contributing
Feel free to message us on [Slack](http://slack.fugue.ai). We also have [contributing instructions](CONTRIBUTING.md).
### Case Studies
* [How LyftLearn Democratizes Distributed Compute through Kubernetes Spark and Fugue](https://eng.lyft.com/how-lyftlearn-democratizes-distributed-compute-through-kubernetes-spark-and-fugue-c0875b97c3d9)
* [Clobotics - Large Scale Image Processing with Spark through Fugue](https://medium.com/fugue-project/large-scale-image-processing-with-spark-through-fugue-e510b9813da8)
* [Architecture for a data lake REST API using Delta Lake, Fugue & Spark (article by bitsofinfo)](https://bitsofinfo.wordpress.com/2023/08/14/data-lake-rest-api-delta-lake-fugue-spark)
### Mentioned Uses
* [Productionizing Data Science at Interos, Inc. (LinkedIn post by Anthony Holten)](https://www.linkedin.com/posts/anthony-holten_pandas-spark-dask-activity-7022628193983459328-QvcF)
* [Multiple Time Series Forecasting with Fugue & Nixtla at Bain & Company (LinkedIn post by Fahad Akbar)](https://www.linkedin.com/posts/fahadakbar_fugue-datascience-forecasting-activity-7041119034813124608-u08q?utm_source=share&utm_medium=member_desktop)
## Further Resources
View some of our latest conferences presentations and content. For a more complete list, check the [Content](https://fugue-tutorials.readthedocs.io/tutorials/resources/content.html) page in the tutorials.
### Blogs
* [Why Pandas-like Interfaces are Sub-optimal for Distributed Computing](https://towardsdatascience.com/why-pandas-like-interfaces-are-sub-optimal-for-distributed-computing-322dacbce43)
* [Introducing FugueSQL — SQL for Pandas, Spark, and Dask DataFrames (Towards Data Science by Khuyen Tran)](https://towardsdatascience.com/introducing-fuguesql-sql-for-pandas-spark-and-dask-dataframes-63d461a16b27)
### Conferences
* [Distributed Machine Learning at Lyft](https://www.youtube.com/watch?v=_IVyIOV0LgY)
* [Comparing the Different Ways to Scale Python and Pandas Code](https://www.youtube.com/watch?v=b3ae0m_XTys)
* [Large Scale Data Validation with Spark and Dask (PyCon US)](https://www.youtube.com/watch?v=2AdvBgjO_3Q)
* [FugueSQL - The Enhanced SQL Interface for Pandas, Spark, and Dask DataFrames (PyData Global)](https://www.youtube.com/watch?v=OBpnGYjNBBI)
* [Distributed Hybrid Parameter Tuning](https://www.youtube.com/watch?v=_GBjqskD8Qk)
| text/markdown | null | The Fugue Development Team <hello@fugue.ai> | null | null | Apache-2.0 | distributed, spark, dask, ray, duckdb, sql, dsl, domain specific language | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"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",
"Programming Language :: Python :: 3 :: Only"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"triad>=1.0.1",
"adagio>=0.2.6",
"pandas<3",
"duckdb>=0.5.0; extra == \"sql\"",
"fugue-sql-antlr>=0.2.4; extra == \"sql\"",
"sqlglot<28; extra == \"sql\"",
"jinja2; extra == \"sql\"",
"fugue-sql-antlr[cpp]>=0.2.4; extra == \"cpp-sql-parser\"",
"pyspark>=3.1.1; extra == \"spark\"",
"zstandard>=0.25.0; extra == \"spark\"",
"dask[dataframe,distributed]>=2024.4.0; extra == \"dask\"",
"pyarrow>=7.0.0; extra == \"dask\"",
"pandas>=2.0.2; extra == \"dask\"",
"ray[data]>=2.30.0; python_version < \"3.14\" and extra == \"ray\"",
"duckdb>=0.5.0; extra == \"ray\"",
"pyarrow>=7.0.0; extra == \"ray\"",
"pandas; extra == \"ray\"",
"fugue-sql-antlr>=0.2.4; extra == \"duckdb\"",
"sqlglot<28; extra == \"duckdb\"",
"jinja2; extra == \"duckdb\"",
"duckdb>=0.5.0; extra == \"duckdb\"",
"numpy; extra == \"duckdb\"",
"polars; extra == \"polars\"",
"fugue-sql-antlr>=0.2.4; extra == \"ibis\"",
"sqlglot<28; extra == \"ibis\"",
"jinja2; extra == \"ibis\"",
"ibis-framework[pandas]; extra == \"ibis\"",
"notebook; extra == \"notebook\"",
"jupyterlab; extra == \"notebook\"",
"ipython>=7.10.0; extra == \"notebook\"",
"fugue-sql-antlr>=0.2.4; extra == \"all\"",
"sqlglot<28; extra == \"all\"",
"jinja2; extra == \"all\"",
"pyspark>=3.1.1; extra == \"all\"",
"dask[dataframe,distributed]>=2024.4.0; extra == \"all\"",
"dask-sql; extra == \"all\"",
"ray[data]>=2.30.0; python_version < \"3.14\" and extra == \"all\"",
"notebook; extra == \"all\"",
"jupyterlab; extra == \"all\"",
"ipython>=7.10.0; extra == \"all\"",
"duckdb>=0.5.0; extra == \"all\"",
"pyarrow>=6.0.1; extra == \"all\"",
"pandas>=2.0.2; extra == \"all\"",
"ibis-framework[duckdb,pandas]; extra == \"all\"",
"polars; extra == \"all\""
] | [] | [] | [] | [
"Homepage, http://github.com/fugue-project/fugue",
"Repository, http://github.com/fugue-project/fugue"
] | 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-20T13:57:54.657612 | fugue-0.9.7.tar.gz | 227,302 | 0f/99/24283b424e7aa85825613f45f2b5db91904661aec719bc0108cac05307a6/fugue-0.9.7.tar.gz | source | sdist | null | false | c132da2379332dc74a913435c718ffbb | 3e38d43ffc4bcdca78ed80628d4fb8bb707ca1fdf3b2abe9b8793e80ac968970 | 0f9924283b424e7aa85825613f45f2b5db91904661aec719bc0108cac05307a6 | null | [
"LICENSE"
] | 93,655 |
2.4 | obsidian-synology-sync | 0.2.3 | Bidirectional Obsidian vault sync to Synology Drive | # obsidian-sync
`obsidian-sync` keeps a local Obsidian vault synchronized with a Synology Drive folder in near real-time.
Primary use case:
- macOS local vault -> Synology Drive folder: `/Users/den/Library/CloudStorage/SynologyDrive-M/obsidian-sync`
- Windows Obsidian opens the same Synology folder (for example `C:\Users\<user>\SynologyDrive\obsidian-sync`)
## Features
- Bidirectional sync (`source_vault <-> synology_vault`)
- Real-time watch mode + periodic reconciliation
- Single-instance lock (prevents concurrent sync writers)
- First-run safe behavior with backups before overwrite/delete
- Conflict policies (`latest`, `source`, `target`, `manual`) + conflict history/restore commands
- Snapshot history and deleted-file recovery commands
- Activity log of sync operations (copy/delete/conflict/restore/error)
- Batch conflict resolver (`resolve-conflicts`)
- Device-state excludes by default (`workspace.json`, caches, plugin temp files)
- Fine-grained vault settings sync toggles (`.obsidian` settings categories)
- Selective attachment-type sync toggles (images/audio/videos/PDF/other)
- Rules engine (folder glob, extension, markdown tag, per-device profile)
- Rename/move mirroring across sides
- Delta patch sync for large files (partial block updates)
- Optional encrypted cloud vault mode (`vault_encryption_enabled`)
- Optional encryption for backups/snapshots/conflict copies (passphrase via env var or CLI flag)
- Health command, integrity audit, optional webhook alerts
- Multi-vault watcher orchestration (`watch-all`)
- SQLite state tracking for deterministic updates/deletes
- Windows-safe filename collision detection (case-only conflicts)
## Install (macOS)
```bash
cd /Users/den/Desktop/obsidian-sync
python3 -m venv .venv
source .venv/bin/activate
pip install .
```
Install from PyPI (after you publish):
```bash
pip install obsidian-synology-sync
```
Install with encryption support:
```bash
pip install 'obsidian-synology-sync[crypto]'
```
## Quick Setup (New Users)
Note: `scripts/macos/setup_new_user.sh` and `scripts/windows/setup_new_user.ps1` are repository files. If you installed only via `pip`, clone this repository to use these setup helpers.
### Passphrase (required for encrypted mode)
The passphrase is user-defined. It is not auto-generated by `obsidian-sync` or Synology.
All devices must use the exact same value.
Recommended for manual runs:
```bash
obsidian-sync --config /path/to/obsidian-sync.toml watch --passphrase 'your-strong-passphrase'
```
```bash
obsidian-sync --config /path/to/obsidian-sync.toml watch --passphrase-file ~/.obsidian-sync-passphrase
```
`--passphrase-file` reads UTF-8 text and ignores one trailing newline.
Set manually on Windows:
```powershell
setx OBSIDIAN_SYNC_PASSPHRASE "your-strong-passphrase"
```
Set manually on macOS:
```bash
export OBSIDIAN_SYNC_PASSPHRASE='your-strong-passphrase'
```
Read current value:
```powershell
[Environment]::GetEnvironmentVariable("OBSIDIAN_SYNC_PASSPHRASE","User")
```
```bash
echo "$OBSIDIAN_SYNC_PASSPHRASE"
```
### macOS user setup (encrypted cloud vault + auto-start)
```bash
cd /Users/den/Desktop/obsidian-sync
pip install 'obsidian-synology-sync[crypto]==0.2.3'
scripts/macos/setup_new_user.sh \
--source "/ABSOLUTE/PATH/TO/YOUR/LOCAL/OBSIDIAN-VAULT" \
--target "/Users/den/Library/CloudStorage/SynologyDrive-M/obsidian-sync" \
--config "/Users/den/Desktop/obsidian-sync/obsidian-sync.toml" \
--passphrase "your-strong-passphrase"
```
What this does:
- creates config if missing
- enables encrypted cloud-vault mode
- installs/restarts launchd auto-start job
- runs one immediate sync
### Windows user setup (encrypted cloud vault + auto-start)
```powershell
cd C:\path\to\obsidian-sync
pip install "obsidian-synology-sync[crypto]==0.2.3"
powershell -ExecutionPolicy Bypass -File .\scripts\windows\setup_new_user.ps1 `
-SourceVault "C:\Users\<user>\ObsidianLocalVault" `
-SynologyVault "C:\Users\<user>\SynologyDrive\obsidian-sync" `
-ConfigPath "C:\Users\<user>\obsidian-sync.toml" `
-Passphrase "your-strong-passphrase"
```
What this does:
- creates config if missing
- enables encrypted cloud-vault mode
- sets passphrase env var and creates a logon scheduled task
- starts watcher immediately
## Initialize
```bash
obsidian-sync init \
--source "/ABSOLUTE/PATH/TO/YOUR/OBSIDIAN-VAULT" \
--target "/Users/den/Library/CloudStorage/SynologyDrive-M/obsidian-sync" \
--windows-path "C:\\Users\\<user>\\SynologyDrive\\obsidian-sync"
```
This creates:
- Config: `obsidian-sync.toml`
- State DB: `.obsidian-sync-state/state.db`
## Run
One-time sync:
```bash
obsidian-sync sync-now
```
One-time sync with encrypted mode passphrase flag:
```bash
obsidian-sync sync-now --passphrase 'your-strong-passphrase'
```
Preview only:
```bash
obsidian-sync sync-now --dry-run
```
Continuous sync:
```bash
obsidian-sync watch
```
Continuous sync with passphrase file:
```bash
obsidian-sync watch --passphrase-file ~/.obsidian-sync-passphrase
```
Continuous sync for multiple vault configs:
```bash
obsidian-sync watch-all --configs /path/a.toml /path/b.toml
```
Status:
```bash
obsidian-sync status
```
List conflict history:
```bash
obsidian-sync conflicts
```
Restore a conflict copy:
```bash
obsidian-sync restore-conflict <ID>
obsidian-sync restore-conflict <ID> --side source
```
Batch resolve open conflicts:
```bash
obsidian-sync resolve-conflicts --policy latest
obsidian-sync resolve-conflicts --policy source
```
List snapshots:
```bash
obsidian-sync snapshots
obsidian-sync snapshots --path "Projects/plan.md"
```
List deleted-file recoveries:
```bash
obsidian-sync deleted-files
```
Restore a snapshot/deleted record:
```bash
obsidian-sync restore-snapshot <SNAPSHOT_ID>
obsidian-sync restore-snapshot <SNAPSHOT_ID> --side target
```
Show activity log:
```bash
obsidian-sync activity --limit 100
obsidian-sync activity --path "Projects/plan.md"
```
Health + integrity audit:
```bash
obsidian-sync health
obsidian-sync audit
obsidian-sync audit --repair
```
## How Windows sync works
Recommended setup:
1. Use Synology Drive client on Windows.
2. Keep `obsidian-sync watch` running on both devices.
3. Open Obsidian on each device at its local `source_vault`.
Mode behavior:
- Plain mode (`vault_encryption_enabled = false`): you can open the Synology local folder directly as a vault.
- Encrypted cloud-vault mode (`vault_encryption_enabled = true`): do not open Synology folder directly. Open local `source_vault` and let `obsidian-sync` decrypt/encrypt between local vault and Synology.
## Backup and conflict behavior
- Before overwrite/delete, existing files are backed up under:
- `<synology_vault>/.obsidian-sync-backups/`
- If both sides changed before sync:
- A `.conflict-...` copy is created for the losing side.
- Newer file (mtime) wins for the main path.
- Conflict entries are stored and can be listed with `obsidian-sync conflicts`.
- Restores are supported with `obsidian-sync restore-conflict`.
## Device-state excludes (default)
By default, device-specific noise is excluded from sync:
- `.obsidian/workspace.json`
- `.obsidian/workspaces.json`
- `.obsidian/cache/**`
- `.obsidian/plugins/*/cache/**`
- `.obsidian/plugins/*/tmp/**`
You can disable this in `obsidian-sync.toml` by setting:
```toml
[sync]
exclude_device_state = false
```
## Fine-Grained Sync Controls
`obsidian-sync.toml` supports the following feature toggles:
```toml
[sync]
# Vault configuration
sync_main_settings = true
sync_appearance_settings = true
sync_themes_and_snippets = true
sync_enabled_plugins = true
sync_hotkeys = true
# File type selection
sync_images = true
sync_audio = true
sync_videos = true
sync_pdfs = true
sync_other_types = true
# Conflict + performance
conflict_policy = "latest" # latest|source|target|manual
delta_sync_enabled = true
delta_min_file_size_bytes = 8388608
delta_chunk_size_bytes = 1048576
delta_max_diff_ratio = 0.5
vault_encryption_enabled = false
encryption_enabled = false
encryption_passphrase_env = "OBSIDIAN_SYNC_PASSPHRASE"
encryption_kdf_iterations = 600000
# Integrity + alerts
integrity_audit_interval_seconds = 3600.0
integrity_auto_repair = false
alerts_webhook_url = ""
alerts_on_conflict = true
alerts_on_error = true
health_stale_after_seconds = 300.0
```
Example: disable videos and PDFs:
```toml
[sync]
sync_videos = false
sync_pdfs = false
```
Enable encrypted backups/snapshots/conflict copies:
```toml
[sync]
encryption_enabled = true
encryption_passphrase_env = "OBSIDIAN_SYNC_PASSPHRASE"
```
Then export the passphrase before running sync:
```bash
export OBSIDIAN_SYNC_PASSPHRASE='your-strong-passphrase'
obsidian-sync watch
```
Or pass it directly for that run:
```bash
obsidian-sync watch --passphrase 'your-strong-passphrase'
obsidian-sync watch --passphrase-file ~/.obsidian-sync-passphrase
```
Main vault files remain plain for Obsidian compatibility; encrypted mode applies to recovery artifacts stored under `.obsidian-sync-backups`.
## Encrypted Cloud Vault Mode
If you want Synology Drive files encrypted at rest (instead of plain `.md`), enable:
```toml
[sync]
vault_encryption_enabled = true
encryption_passphrase_env = "OBSIDIAN_SYNC_PASSPHRASE"
```
Behavior:
- Local `source_vault` stays plaintext (Obsidian opens this directly).
- Synology `synology_vault` stores encrypted files as `*.osync.enc`.
- Run `obsidian-sync` on every device (macOS/Windows) with the same passphrase (env var or CLI flag) so each device can decrypt to its local vault.
## Recovery and Activity
- `snapshots` includes version-like copies captured during sync and backup events.
- `deleted-files` shows deleted note/attachment recoveries.
- `restore-snapshot` restores any snapshot or deleted entry to source/target.
- `activity` shows a durable log of sync operations and restore actions.
## Rules Engine
Use `[sync]` and profile blocks to control selection by path/extension/tag:
```toml
[sync]
device_profile = "windows"
rules_include_globs = ["Projects/**", "Inbox/**"]
rules_exclude_globs = ["Archive/**"]
rules_include_extensions = [".md", ".canvas", ".pdf"]
rules_exclude_extensions = [".tmp"]
rules_include_tags = ["work"]
rules_exclude_tags = ["private"]
[profiles.windows]
rules_exclude_globs = [".obsidian/plugins/heavy-plugin/**"]
```
Rules are merged from `[sync]` + `[profiles.<device_profile>]`.
## Scope Note
This project implements local/Synology-based equivalents of Obsidian Sync workflow features.
Hosted service features from Obsidian's cloud product are out of scope here:
- Obsidian account authentication and hosted relay infrastructure
- Shared vault invite/permission management UI
- Cloud-managed end-to-end key exchange and recovery UX
## Auto-start on login
macOS (`launchd`):
```bash
scripts/macos/setup_new_user.sh \
--source "/ABSOLUTE/PATH/TO/YOUR/LOCAL/OBSIDIAN-VAULT" \
--target "/Users/den/Library/CloudStorage/SynologyDrive-M/obsidian-sync" \
--config "/Users/den/Desktop/obsidian-sync/obsidian-sync.toml" \
--passphrase "your-strong-passphrase"
```
Windows (Task Scheduler):
```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\windows\setup_new_user.ps1 `
-SourceVault "C:\Users\<user>\ObsidianLocalVault" `
-SynologyVault "C:\Users\<user>\SynologyDrive\obsidian-sync" `
-ConfigPath "C:\Users\<user>\obsidian-sync.toml" `
-Passphrase "your-strong-passphrase"
```
## Build and publish (pip distributable)
Build and validate distributions:
```bash
cd /Users/den/Desktop/obsidian-sync
scripts/release/build_dist.sh
```
Upload:
```bash
# TestPyPI first
scripts/release/publish.sh testpypi
# Production PyPI
scripts/release/publish.sh pypi
```
`twine` uses `TWINE_USERNAME` and `TWINE_PASSWORD` (or keyring) for authentication.
## Notes
- Avoid storing two files that differ only by case (for Windows compatibility).
- Keep file names and paths stable between macOS and Windows.
- For very large vaults, first sync may take time.
| text/markdown | null | null | null | null | null | obsidian, synology, sync, notes | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows",
"Topic :: Utilities"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"watchdog>=4.0.0",
"cryptography>=42.0.0; extra == \"crypto\"",
"build>=1.0.0; extra == \"dev\"",
"cryptography>=42.0.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\"",
"twine>=5.0.0; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.0 | 2026-02-20T13:57:19.189671 | obsidian_synology_sync-0.2.3.tar.gz | 37,706 | 2f/d8/ef7fa8a55592248d22da9157c24c98cb24b045ec8b78a668bdf251a9987c/obsidian_synology_sync-0.2.3.tar.gz | source | sdist | null | false | 61752c7f49848b845e3b105097488990 | d15dd6a940c2f2c1e0096cd41efa11d06691a4ef1546e9453e472e46e2bd1c93 | 2fd8ef7fa8a55592248d22da9157c24c98cb24b045ec8b78a668bdf251a9987c | null | [] | 208 |
2.4 | isage-common | 0.2.4.13 | SAGE 框架核心公共工具包 | # SAGE Common
> SAGE 框架的核心工具和共享组件
[](https://www.python.org/downloads/)
[](../../LICENSE)
## 📋 Overview
**SAGE Common** 提供所有 SAGE 包共用的基础工具和组件。 这是基础层（L1），提供：
## 🧭 Governance / 团队协作制度
- `docs/governance/TEAM.md`
- `docs/governance/MAINTAINERS.md`
- `docs/governance/DEVELOPER_GUIDE.md`
- `docs/governance/PR_CHECKLIST.md`
- `docs/governance/SELF_HOSTED_RUNNER.md`
- `docs/governance/TODO.md`
- **配置管理** - YAML/TOML 文件支持
- **日志框架** - 自定义格式化器和处理程序
- **网络工具** - TCP/UDP 通信支持
- **序列化工具** - dill 和 pickle 支持
- **系统工具** - 环境和进程管理
- **嵌入服务** - sage_embedding、sage_llm
该包确保 SAGE 生态系统的一致性并减少代码重复。
## ✨ Features
- **统一配置** - YAML/TOML 配置加载和验证
- **高级日志** - 彩色输出、结构化日志、自定义格式器
- **网络工具** - TCP 客户端/服务器、网络助手
- **灵活序列化** - 多种后端（dill、pickle、JSON）
- **系统管理** - 环境检测、进程控制
- **LLM 集成** - 嵌入和 vLLM 服务
## 🚀 Quick Start
### 配置管理
```python
from sage.common.utils.config import load_config
# 加载 YAML 配置
config = load_config("config.yaml")
print(config["database"]["host"])
```
### 日志记录
```python
from sage.common.utils.logging import get_logger
logger = get_logger(__name__)
logger.info("Processing started")
logger.error("An error occurred", extra={"user_id": 123})
```
### 序列化
```python
from sage.common.utils.serialization import UniversalSerializer
serializer = UniversalSerializer()
data = {"key": "value", "nested": {"data": [1, 2, 3]}}
serialized = serializer.serialize(data)
deserialized = serializer.deserialize(serialized)
```
## 核心模块
- **utils.config** - 配置管理工具
- **utils.logging** - 日志框架和格式化器
- **utils.network** - 网络工具和 TCP 客户端/服务器
- **utils.serialization** - 序列化工具（包含 dill 支持）
- **utils.system** - 环境和进程管理的系统工具
- **\_version** - 版本管理
## 📦 Package Structure
```
sage-common/
├── src/
│ └── sage/
│ └── common/
│ ├── __init__.py
│ ├── _version.py
│ ├── utils/ # 核心工具
│ │ ├── config/ # 配置管理
│ │ ├── logging/ # 日志框架
│ │ ├── network/ # 网络工具
│ │ ├── serialization/ # 序列化工具
│ │ └── system/ # 系统工具
│ └── components/ # 共享组件
│ ├── sage_embedding/ # 嵌入服务
│ └── sage_llm/ # vLLM 服务
├── tests/
├── pyproject.toml
└── README.md
```
## 🚀 Installation
### 基础安装
```bash
pip install isage-common
```
### 开发安装
```bash
cd packages/sage-common
pip install -e .
```
### 可选依赖安装
```bash
# 嵌入支持
pip install isage-common[embedding]
# vLLM 支持
pip install isage-common[vllm]
# 完整安装
pip install isage-common[all]
```
## 📖 快速开始
### 配置管理
```python
from sage.common.utils.config.loader import ConfigLoader
# 加载配置
config = ConfigLoader("config.yaml")
# 访问配置
model_name = config.get("model.name", default="default-model")
```
### 日志
```python
from sage.common.utils.logging.custom_logger import get_logger
# 获取日志器
logger = get_logger(__name__)
# 使用日志器
logger.info("应用程序已启动")
logger.debug("调试信息")
logger.error("发生错误", exc_info=True)
```
### 网络工具
```python
from sage.common.utils.network import TCPClient, TCPServer
# 创建 TCP 服务器
server = TCPServer(host="localhost", port=8080)
server.start()
# 创建 TCP 客户端
client = TCPClient(host="localhost", port=8080)
client.connect()
client.send(b"你好，服务器！")
```
### 序列化
```python
from sage.common.utils.serialization import serialize, deserialize
# 序列化数据
data = {"key": "value", "numbers": [1, 2, 3]}
serialized = serialize(data, format="dill")
# 反序列化数据
restored = deserialize(serialized, format="dill")
```
## 🔧 Configuration
配置文件通常使用 YAML 或 TOML 格式：
```yaml
# config.yaml
logging:
level: INFO
format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
network:
host: localhost
port: 8080
timeout: 30
embedding:
model: sentence-transformers/all-MiniLM-L6-v2
device: cuda
```
## 🧪 Testing
```bash
# 运行单元测试
pytest tests/unit
# 运行集成测试
pytest tests/integration
# 运行覆盖率测试
pytest --cov=sage.common --cov-report=html
```
## 📚 Documentation
- **用户指南** - 查看 [docs-public](https://intellistream.github.io/SAGE-Pub/guides/packages/sage-common/)
- **API 参考** - 查看包文档字符串和类型提示
- **示例** - 查看各模块中的 `examples/` 目录
## 🤝 Contributing
欢迎贡献！请查看 [CONTRIBUTING.md](../../CONTRIBUTING.md) 了解指导原则。
## 📄 License
该项目采用 MIT 许可证 - 详情请查看 [LICENSE](../../LICENSE) 文件。
## 🔗 相关包
- **sage-kernel** - 使用通用工具进行运行时管理
- **sage-libs** - 基于通用组件构建库
- **sage-middleware** - 使用网络和序列化工具
- **sage-tools** - 使用配置和日志工具
## 📮 支持
- **文档** - https://intellistream.github.io/SAGE-Pub/
- **问题** - https://github.com/intellistream/SAGE/issues
- **讨论** - https://github.com/intellistream/SAGE/discussions
______________________________________________________________________
**SAGE 框架的一部分** | [主仓库](https://github.com/intellistream/SAGE)
| text/markdown | null | IntelliStream Team <shuhao_zhang@hust.edu.cn> | null | null | MIT | ai, sage, machine learning, artificial intelligence, core, utilities, framework, infrastructure | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
] | [] | null | null | ==3.11.* | [] | [] | [] | [
"pyyaml>=6.0",
"psutil>=6.1.0",
"dill>=0.3.8",
"numpy<2.3.0,>=1.26.0",
"pydantic<3.0.0,>=2.10.0",
"platformdirs>=4.0.0",
"pytest>=7.4.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"ruff==0.14.6; extra == \"dev\"",
"isage-pypi-publisher>=0.2.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/intellistream/SAGE",
"Documentation, https://intellistream.github.io/SAGE-Pub/",
"Repository, https://github.com/intellistream/SAGE",
"Issues, https://github.com/intellistream/SAGE/issues"
] | twine/6.2.0 CPython/3.11.11 | 2026-02-20T13:57:09.688159 | isage_common-0.2.4.13.tar.gz | 340,650 | 53/cf/1c5a3678e790bb5c7875d7cac309670c37a34c94de09f55a59d0f1c93c93/isage_common-0.2.4.13.tar.gz | source | sdist | null | false | ebdc1b219001ebeca214a1a21c951767 | 04d6d3fb9093ddad2950f5375c4feb0dacc8bf411179a14de8dc1c6579768ad7 | 53cf1c5a3678e790bb5c7875d7cac309670c37a34c94de09f55a59d0f1c93c93 | null | [] | 157 |
2.4 | isage-kernel | 0.2.4.14 | SAGE Kernel Module - Streaming-Augmented Generative Execution | # SAGE Kernel
> 🚀 SAGE 框架的核心内核包 - 整合了核心框架和命令行工具
## 📋 Overview
**SAGE Kernel** 是 SAGE 框架的核心包，整合了原来的 `sage-kernel` 和 `sage-cli` 两个包的功能，提供数据流处理引擎、任务管理、运行时系统和命令行工具。
## 🧭 Governance / 团队协作制度
- `docs/governance/TEAM.md`
- `docs/governance/MAINTAINERS.md`
- `docs/governance/DEVELOPER_GUIDE.md`
- `docs/governance/PR_CHECKLIST.md`
- `docs/governance/SELF_HOSTED_RUNNER.md`
- `docs/governance/TODO.md`
## � Package Contents
**SAGE Kernel** 是 SAGE 框架的核心包，整合了原来的 `sage-kernel` 和 `sage-cli` 两个包的功能：
### 🏗️ 核心组件 (sage.core)
- **数据流处理框架**: 高性能的 dataflow-native 处理引擎
- **函数管理**: Function registry 和 operator 管理
- **配置系统**: 统一的配置管理和验证
### ⚙️ 任务管理 (sage.kernels.jobmanager)
- **任务调度**: 分布式任务执行和调度
- **执行图**: DAG 执行图构建和优化
- **客户端接口**: JobManager 客户端和服务端
### 🔧 运行时系统 (sage.kernels.runtime)
- **服务工厂**: 任务和服务的动态创建
- **通信队列**: 高性能的进程间通信
- **服务管理**: 微服务架构的服务生命周期管理
### 💻 命令行工具 (sage.cli)
- **集群管理**: 分布式集群的部署和管理
- **任务提交**: 命令行任务提交和监控
- **配置管理**: 交互式配置设置和验证
- **扩展管理**: 插件和扩展的安装管理
## 🚀 Installation
### From Source
```bash
# 从源码安装
pip install -e packages/sage-kernel
# 或者从 PyPI 安装（发布后）
pip install intellistream-sage-kernel
```
## 📖 Quick Start
### Using Core API
```python
from sage.core import Function, Config
from sage.kernels.jobmanager import JobManager
from sage.kernels.runtime import ServiceTaskFactory
# 创建并使用函数
@Function
def my_processor(data):
return data * 2
# 使用 JobManager
job_manager = JobManager()
job = job_manager.submit_job(my_processor, data=[1, 2, 3])
```
### 使用命令行工具
```bash
# 启动 SAGE 集群
sage cluster start
# 提交任务
sage job submit my_job.py
# 管理配置
sage config set utils.provider openai
sage config show
# 查看帮助
sage --help
```
## 🏗️ 架构设计
```
sage-kernel/
├── src/sage/
│ ├── core/ # 核心框架
│ ├── jobmanager/ # 任务管理
│ ├── runtime/ # 运行时系统
│ └── cli/ # 命令行工具
├── tests/ # 标准化测试结构
│ ├── core/
│ ├── jobmanager/
│ ├── runtime/
│ └── cli/
└── pyproject.toml # 统一配置
```
## 🧪 测试
```bash
# 运行所有测试
pytest
# 运行特定模块测试
pytest tests/core/
pytest tests/cli/
# 运行覆盖率测试
pytest --cov=sage --cov-report=html
```
## 🔧 开发环境
```bash
# 安装开发依赖
pip install -e "packages/sage-kernel[dev]"
# 安装增强CLI功能
pip install -e "packages/sage-kernel[enhanced]"
# 代码格式化
black src/ tests/
ruff check src/ tests/
# 类型检查
mypy src/sage
```
## 📚 依赖关系
### 内部依赖
- `sage-utils`: 基础工具包
### 外部核心依赖
- **ML/AI**: torch, transformers, sentence-transformers, faiss-cpu
- **Web/API**: fastapi, uvicorn, aiohttp
- **数据处理**: numpy, pandas, scipy, scikit-learn
- **CLI**: typer, rich, click, questionary
- **配置**: pydantic, PyYAML, python-dotenv
## 🎯 设计理念
### 单一内核原则
将核心框架和 CLI 工具合并到一个包中，遵循以下原则：
1. **统一入口**: 所有核心功能通过一个包提供
1. **逻辑分离**: 不同组件保持清晰的模块边界
1. **依赖优化**: 避免循环依赖，清晰的依赖层次
1. **测试标准化**: 所有测试文件位于标准 `tests/` 目录
### CLI 集成策略
- CLI 功能完全集成到内核包中
- 通过入口点 `sage` 和 `sage-kernel` 提供命令行访问
- CLI 模块不污染核心 API 的导入
## 🔄 从旧包迁移
如果你之前使用 `sage-kernel` 或 `sage-cli`：
```python
# 旧代码
from sage_core import Function
from sage_cli.main import app
# 新代码
from sage.core import Function
# CLI 通过命令行使用: sage command
```
## 📋 TODO
- [ ] 完善模块间的导入优化
- [ ] 添加性能基准测试
- [ ] 完善CLI命令的集成测试
- [ ] 优化依赖版本冲突问题
- [ ] 添加更多示例代码
## 🤝 贡献
请查看项目根目录的贡献指南。对于 kernel 相关的开发：
1. 确保测试位于 `tests/` 目录
1. 保持模块间的清晰边界
1. CLI 功能通过入口点而非直接导入使用
1. 遵循现有的代码风格和架构模式
______________________________________________________________________
🔗 **相关包**: [sage-utils](../sage-utils/) | [sage-extensions](../sage-extensions/) |
[sage-lib](../sage-lib/)
## 📄 License
MIT License - see [LICENSE](../../LICENSE) for details.
| text/markdown | null | IntelliStream Team <shuhao_zhang@hust.edu.cn> | null | null | MIT | data, reasoning, kernel, dataflow, llm, ml, framework, rag, intellistream, cli, ai, sage | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Operating System :: OS Independent",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Distributed Computing"
] | [] | null | null | ==3.11.* | [] | [] | [] | [
"torch<3.0.0,>=2.7.0",
"torchvision<1.0.0,>=0.22.0",
"fastapi<1.0.0,>=0.115.0",
"uvicorn[standard]<1.0.0,>=0.34.0",
"python_multipart<0.1.0,>=0.0.20",
"ray<3.0.0,>=2.48.0",
"grpcio<2.0.0,>=1.74.0",
"protobuf<7.0.0,>=6.32.0",
"msgpack<2.0.0,>=1.1.0",
"aioboto3<15.0.0,>=14.1.0",
"typer<1.0.0,>=0.15.0",
"rich<14.0.0,>=13.0.0",
"click<9.0.0,>=8.0.0",
"questionary<2.0.0,>=1.10.0",
"prompt_toolkit<4.0.0,>=3.0.50",
"tabulate<1.0.0,>=0.9.0",
"Cython<4.0.0,>=3.1.0",
"pybind11<4.0.0,>=3.0.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest-benchmark>=4.0.0; extra == \"dev\"",
"ruff==0.14.6; extra == \"dev\"",
"isage-pypi-publisher>=0.2.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/intellistream/SAGE",
"Repository, https://github.com/intellistream/SAGE.git",
"Documentation, https://intellistream.github.io/SAGE-Pub/",
"Issues, https://github.com/intellistream/SAGE/issues"
] | twine/6.2.0 CPython/3.11.11 | 2026-02-20T13:57:03.770741 | isage_kernel-0.2.4.14.tar.gz | 404,340 | e2/b6/86a19eaa6b729babc983b96405ee92b10cc050322fbfc1e5703dd962db09/isage_kernel-0.2.4.14.tar.gz | source | sdist | null | false | abd70ab4808da927238d63216751d794 | 36905ccad73bc6fdc3d2f926b288f214b496861876e828506a8141bc4a8d3382 | e2b686a19eaa6b729babc983b96405ee92b10cc050322fbfc1e5703dd962db09 | null | [] | 153 |
2.4 | nnetsauce | 0.51.0 | Quasi-randomized (neural) networks | Quasi-randomized (neural) networks for regression, classification and time series forecasting
| null | T. Moudiki | thierry.moudiki@gmail.com | null | null | BSD Clause Clear | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3"
] | [] | https://techtonique.github.io/nnetsauce/ | https://github.com/Techtonique/nnetsauce | null | [] | [] | [] | [
"joblib",
"GPopt",
"matplotlib",
"numpy",
"pandas",
"requests",
"scipy",
"scikit-learn",
"statsmodels",
"threadpoolctl",
"tqdm",
"jax; extra == \"jax\"",
"jaxlib; extra == \"jax\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T13:56:42.994445 | nnetsauce-0.51.0.tar.gz | 187,339 | 7d/75/b3ca02bdfa48b999fe351211cf72ccf170059df5636791cc90ad1ff6e05a/nnetsauce-0.51.0.tar.gz | source | sdist | null | false | 4a3ccc250f2f4abc98da31563c0202f6 | d3691aea85833e4aec5fbd7e171e27a2d350cb409ab46138f785e83ba02596d6 | 7d75b3ca02bdfa48b999fe351211cf72ccf170059df5636791cc90ad1ff6e05a | null | [
"LICENSE"
] | 229 |
2.4 | causalis | 0.1.8 | A Python toolkit for causal inference and experimentation | # Causalis
[](LICENSE)
<a href="https://causalis.causalcraft.com/"><img src="https://raw.githubusercontent.com/causalis-causalcraft/Causalis/main/notebooks/new_logo_big.svg" alt="Causalis logo" width="80" style="float: left; margin-right: 10px;" /></a>
Robust causal inference for experiments and observational studies in Python, organized around **scenarios** (e.g., Classic RCT, CUPED, Unconfoundedness) with a consistent `fit() → estimate()` workflow.
- 📚 Documentation & notebooks: https://causalis.causalcraft.com/
- 🔎 API reference: https://causalis.causalcraft.com/api-reference
## Why Causalis?
Causalis focuses on:
- Scenario-first workflows (you pick the study design; Causalis provides best-practice defaults).
- Guardrails and diagnostics (e.g., SRM checks, balance checks).
- Typed data contracts (`CausalData`) to fail fast on schema issues.
## Installation
### Recommended
```bash
pip install causalis
```
# Quickstart: Classic RCT (difference in means + inference)
```python
from causalis.dgp import generate_classic_rct_26
from causalis.scenarios.classic_rct import DiffInMeans, check_srm
# Synthetic RCT data as a validated CausalData object
data = generate_classic_rct_26(seed=42, return_causal_data=True)
# Optional: Sample Ratio Mismatch check
srm = check_srm(data, target_allocation={0: 0.5, 1: 0.5}, alpha=1e-3)
print("SRM detected?", srm.is_srm, "p=", srm.p_value, "chi2=", srm.chi2)
# Estimate treatment effect with t-test inference (or bootstrap / conversion_ztest)
result = DiffInMeans().fit(data).estimate(method="ttest", alpha=0.05)
result.summary()
```
# Quickstart: Observational study (Unconfoundedness / DML IRM)
```python
from causalis.scenarios.unconfoundedness.dgp import generate_obs_hte_26
from causalis.scenarios.unconfoundedness import IRM
from causalis.data_contracts import CausalData
causaldata = generate_obs_hte_26(return_causal_data=True, include_oracle=False)
from causalis.scenarios.unconfoundedness import IRM
model = IRM().fit(causaldata)
result = model.estimate(score='ATTE')
result.summary()
```
# Pick your scenario
Classic RCT: randomized assignment (no pre-period metric).
CUPED: randomized assignment with pre-period metric for variance reduction.
Unconfoundedness: observational study adjusting for measured confounders (DML IRM).
See scenario notebooks: https://causalis.causalcraft.com/explore-scenarios
# Responsible use / limitations
Causal estimates require identification assumptions (e.g., randomization or unconfoundedness + overlap).
Causalis can help with diagnostics, but it cannot guarantee assumptions hold in your data.
# Contributing
Contributions are welcome—bug reports, docs fixes, notebooks, and new estimators.
Please read CONTRIBUTING.md and follow the Code of Conduct.
# Getting help
Questions: GitHub Discussions
Bugs: GitHub Issues (include minimal repro + versions)
# License
MIT (see LICENSE).
| text/markdown | causalis Team | null | null | null | MIT | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"numpy",
"pandas",
"scipy",
"statsmodels",
"scikit-learn",
"pydantic",
"catboost",
"pytest>=6.0; extra == \"dev\"",
"black; extra == \"dev\"",
"isort; extra == \"dev\"",
"flake8; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.2 | 2026-02-20T13:56:39.341924 | causalis-0.1.8.tar.gz | 168,754 | a0/19/1c126a2403d975ac96c0e6d0a3b667a0faa9751509d802a8066edd4efb0d/causalis-0.1.8.tar.gz | source | sdist | null | false | f75b9898a26b9dd2bc791d914e022a0a | 0e2029f64e0b6fc90169c9ab8d1738e4e96bcb8b4a3e58004a37bfb6d0e50dda | a0191c126a2403d975ac96c0e6d0a3b667a0faa9751509d802a8066edd4efb0d | null | [
"LICENSE"
] | 209 |
2.4 | timedb | 0.1.2 | timedb — opinionated schema & API for time series | # TimeDB
**TimeDB** is an **open source, opinionated time series database** built on **PostgreSQL** and **TimescaleDB** designed to natively handle **overlapping forecast revisions**, **auditable human-in-the-loop updates**, and **"time-of-knowledge" history** through a three-dimensional temporal data model. TimeDB provides a seamless workflow through its **Python SDK** and **FastAPI** backend.
## Features
- **Time-of-Knowledge History**: Track not just when data is valid, but when it became known
- **Forecast Revisions**: Store overlapping forecasts with full provenance
- **Auditable Updates**: Every change records who, what, when, and why
- **Backtesting Ready**: Query historical data as of any point in time
- **Label-Based Organization**: Filter series by meaningful dimensions
## Why timedb?
Traditional time series databases assume one immutable value per timestamp. **TimeDB** is built for domains where:
- 📊 **Forecasts evolve**: Multiple predictions for the same timestamp from different times
- 🔄 **Data gets corrected**: Manual adjustments need audit trails, not overwrites
- ⏪ **Backtesting requires history**: "What did we know on Monday?" vs "what do we know now?"
- ✏️ **Humans review data**: Track who changed what, when, and why
## Quick Start
```bash
pip install timedb
```
```python
import timedb as td
import pandas as pd
from datetime import datetime, timezone
td.create()
# Create a forecast series
td.create_series(name="wind_power", unit="MW",
labels={"site": "offshore_1"}, overlapping=True)
# Insert forecast with knowledge_time
knowledge_time = datetime(2025, 1, 1, 18, 0, tzinfo=timezone.utc)
df = pd.DataFrame({
'valid_time': pd.date_range('2025-01-01', periods=24, freq='h', tz='UTC'),
'value': [100 + i*2 for i in range(24)]
})
td.get_series("wind_power").where(site="offshore_1").insert(df=df, knowledge_time=knowledge_time)
# Read latest forecast
df_latest = td.get_series("wind_power").where(site="offshore_1").read()
# Read all forecast revisions
df_all = td.get_series("wind_power").where(site="offshore_1").read(versions=True)
```
> For custom connection settings (host, pool size, etc.), use `TimeDataClient` directly:
> `from timedb import TimeDataClient; td = TimeDataClient(conninfo="postgresql://...")`
## Try in Google Colab
Try the quickstart in Colab — no local setup required. The first cell installs PostgreSQL + TimescaleDB automatically inside the Colab VM (~2 min).
[](https://colab.research.google.com/github/rebase-energy/timedb/blob/main/examples/quickstart.ipynb)
Additional notebooks and Google Colab links are available in the [examples directory](examples/).
> **Note**: The Colab setup cell installs PostgreSQL 14 + TimescaleDB. Data persists only within the active Colab session.
## Documentation
- [Installation Guide](docs/installation.rst)
- [SDK Documentation](docs/sdk.rst)
- [REST API Reference](docs/api_reference.rst)
- [Examples & Notebooks](examples/)
- [Development Guide](DEVELOPMENT.md)
## Data Model
Three time dimensions:
| Dimension | Description | Example |
|-----------|-------------|---------|
| **valid_time** | The time the value represents a fact for | "Wind speed forecast for Wednesday 12:00" |
| **knowledge_time** | The time when the value was known | "Wind speed forecast for Wednesday 12:00 was generated on Monday 18:00" |
| **change_time** | The time when the value was changed | "Wind speed forecast for Wednesday 12:00 was manually changed on Tuesday 9:00" |
Plus metadata: `tags`, `annotation`, `changed_by`, `change_time` for audit trails.
## Requirements
- Python 3.9+
- PostgreSQL 12+ with TimescaleDB
- (Optional) Jupyter for notebooks
## Contributing
Contributions welcome! See [DEVELOPMENT.md](DEVELOPMENT.md) for setup instructions.
## Contributors
<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
<!-- prettier-ignore-start -->
<!-- markdownlint-disable -->
<!-- markdownlint-restore -->
<!-- prettier-ignore-end -->
<!-- ALL-CONTRIBUTORS-LIST:END -->
## License
Apache-2.0
## See Also
- [Official Documentation](https://timedb.readthedocs.io/)
- [Examples Repository](examples/)
- [Issue Tracker](https://github.com/rebase-energy/timedb/issues)
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.9 | [] | [] | [] | [
"typer>=0.9.0",
"psycopg[binary]>=3.1",
"psycopg_pool>=3.1",
"python-dotenv>=0.21",
"fastapi>=0.104.0",
"uvicorn[standard]>=0.24.0",
"pydantic>=2.0.0",
"pandas>=2.0.0",
"requests>=2.32.5",
"modal>=1.2.6",
"pytest>=8.4.2; extra == \"test\"",
"pytest-cov>=5.0.0; extra == \"test\"",
"pint>=0.23; extra == \"test\"",
"pint-pandas>=0.6; extra == \"test\"",
"nbmake>=1.5; extra == \"test\"",
"ipykernel>=6.31.0; extra == \"notebooks\"",
"jupyter>=1.1.1; extra == \"notebooks\"",
"notebook>=7.5.2; extra == \"notebooks\"",
"seaborn>=0.13.2; extra == \"notebooks\"",
"pint>=0.23; extra == \"pint\"",
"pint-pandas>=0.6; extra == \"pint\"",
"sphinx>=7.4.7; extra == \"docs\"",
"nbsphinx>=0.9.8; extra == \"docs\"",
"sphinx-rtd-theme>=3.1.0; extra == \"docs\""
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-20T13:56:34.715561 | timedb-0.1.2.tar.gz | 44,696 | 9e/2c/f13feb4519dd9318e8b49e25bdac54fed550e5f3965fce87a4d4872d41e7/timedb-0.1.2.tar.gz | source | sdist | null | false | 51d41e221d81b7eabdc7ac5526cc773d | f817139a62ed6d7a1ac8e4388107207063a16988390c5bde810bbf091ec69e14 | 9e2cf13feb4519dd9318e8b49e25bdac54fed550e5f3965fce87a4d4872d41e7 | null | [
"LICENSE"
] | 205 |
2.4 | matrice-analytics | 0.1.174 | Common server utilities for Matrice.ai services | # Post-Processing Module - Refactored Architecture
## Overview
This module provides a comprehensive, refactored post-processing system for the Matrice Python SDK. The system has been completely redesigned to be more pythonic, maintainable, and extensible while providing powerful analytics capabilities for various use cases.
## 🚀 Key Features
### ✅ **Unified Architecture**
- **Single Entry Point**: `PostProcessor` class handles all processing needs
- **Standardized Results**: All operations return `ProcessingResult` objects
- **Consistent Configuration**: Type-safe configuration system with validation
- **Registry Pattern**: Easy registration and discovery of use cases
### ✅ **Separate Use Case Classes**
- **People Counting**: Advanced people counting with zone analysis and tracking
- **Customer Service**: Comprehensive customer service analytics with business intelligence
- **Extensible Design**: Easy to add new use cases
### ✅ **Pythonic Configuration Management**
- **Dataclass-based**: Type-safe configurations using dataclasses
- **Nested Configurations**: Support for complex nested config structures
- **File Support**: JSON/YAML configuration file loading and saving
- **Validation**: Built-in validation with detailed error messages
### ✅ **Comprehensive Error Handling**
- **Standardized Errors**: All errors return structured `ProcessingResult` objects
- **Detailed Information**: Error messages include type, context, and debugging info
- **Graceful Degradation**: System continues operating even with partial failures
### ✅ **Processing Statistics**
- **Performance Tracking**: Automatic processing time measurement
- **Success Metrics**: Success/failure rates and statistics
- **Insights Generation**: Automatic generation of actionable insights
## 📁 Architecture
```
post_processing/
├── __init__.py # Main exports and convenience functions
├── processor.py # Main PostProcessor class
├── README.md # This documentation
│
├── core/ # Core system components
│ ├── __init__.py
│ ├── base.py # Base classes, enums, and protocols
│ ├── config.py # Configuration system
│ └── advanced_usecases.py # Advanced use case implementations
│
├── usecases/ # Separate use case implementations
│ ├── __init__.py
│ ├── people_counting.py # People counting use case
│ └── customer_service.py # Customer service use case
│
└── utils/ # Utility functions organized by category
├── __init__.py
├── geometry_utils.py # Geometric calculations
├── format_utils.py # Format detection and conversion
├── filter_utils.py # Filtering and cleaning operations
├── counting_utils.py # Counting and aggregation
└── tracking_utils.py # Tracking and movement analysis
```
## 🛠 Quick Start
### Basic Usage
```python
from matrice_analytics.post_processing import PostProcessor, process_simple
# Method 1: Simple processing (recommended for quick tasks)
result = process_simple(
raw_results,
usecase="people_counting",
confidence_threshold=0.5
)
# Method 2: Using PostProcessor class (recommended for complex workflows)
processor = PostProcessor()
result = processor.process_simple(
raw_results,
usecase="people_counting",
confidence_threshold=0.5,
enable_tracking=True
)
print(f"Status: {result.status.value}")
print(f"Summary: {result.summary}")
print(f"Insights: {len(result.insights)} generated")
```
### Advanced Configuration
```python
# Create complex configuration
config = processor.create_config(
'people_counting',
confidence_threshold=0.6,
enable_tracking=True,
person_categories=['person', 'people', 'human'],
zone_config={
'zones': {
'entrance': [[0, 0], [100, 0], [100, 100], [0, 100]],
'checkout': [[200, 200], [300, 200], [300, 300], [200, 300]]
}
},
alert_config={
'count_thresholds': {'all': 10},
'occupancy_thresholds': {'entrance': 5}
}
)
# Process with configuration
result = processor.process(raw_results, config)
```
### Configuration File Support
```python
# Save configuration to file
processor.save_config(config, "people_counting_config.json")
# Load and use configuration from file
result = processor.process_from_file(raw_results, "people_counting_config.json")
```
## 📊 Use Cases
### 1. People Counting (`people_counting`)
Advanced people counting with comprehensive analytics:
```python
result = process_simple(
raw_results,
usecase="people_counting",
confidence_threshold=0.5,
enable_tracking=True,
person_categories=['person', 'people'],
zone_config={
'zones': {
'entrance': [[0, 0], [100, 0], [100, 100], [0, 100]]
}
}
)
```
**Features:**
- Multi-category person detection
- Zone-based counting and analysis
- Unique person tracking
- Occupancy analysis
- Alert generation based on thresholds
- Temporal analysis and trends
### 2. Customer Service (`customer_service`)
Comprehensive customer service analytics:
```python
result = process_simple(
raw_results,
usecase="customer_service",
confidence_threshold=0.6,
service_proximity_threshold=50.0,
staff_categories=['staff', 'employee'],
customer_categories=['customer', 'person']
)
```
**Features:**
- Staff utilization analysis
- Customer-staff interaction detection
- Service quality metrics
- Area occupancy analysis
- Queue management insights
- Business intelligence metrics
## 🔧 Configuration System
### Configuration Classes
All configurations are type-safe dataclasses with built-in validation:
```python
from matrice_analytics.post_processing import PeopleCountingConfig, ZoneConfig
# Create configuration programmatically
config = PeopleCountingConfig(
confidence_threshold=0.5,
enable_tracking=True,
zone_config=ZoneConfig(
zones={
'entrance': [[0, 0], [100, 0], [100, 100], [0, 100]]
}
)
)
# Validate configuration
errors = config.validate()
if errors:
print(f"Configuration errors: {errors}")
```
### Configuration Templates
```python
# Get configuration template for a use case
template = processor.get_config_template('people_counting')
print(f"Available options: {list(template.keys())}")
# List all available use cases
use_cases = processor.list_available_usecases()
print(f"Available use cases: {use_cases}")
```
## 📈 Processing Results
All processing operations return a standardized `ProcessingResult` object:
```python
class ProcessingResult:
data: Any # Processed data
status: ProcessingStatus # SUCCESS, ERROR, WARNING, PARTIAL
usecase: str # Use case name
category: str # Use case category
processing_time: float # Processing time in seconds
summary: str # Human-readable summary
insights: List[str] # Generated insights
warnings: List[str] # Warning messages
error_message: Optional[str] # Error message if failed
predictions: List[Dict[str, Any]] # Detailed predictions
metrics: Dict[str, Any] # Performance metrics
```
### Working with Results
```python
result = processor.process_simple(data, "people_counting")
# Check status
if result.is_success():
print(f"✅ {result.summary}")
# Access insights
for insight in result.insights:
print(f"💡 {insight}")
# Access metrics
print(f"📊 Metrics: {result.metrics}")
# Access processed data
processed_data = result.data
else:
print(f"❌ Processing failed: {result.error_message}")
```
## 📊 Statistics and Monitoring
```python
# Get processing statistics
stats = processor.get_statistics()
print(f"Total processed: {stats['total_processed']}")
print(f"Success rate: {stats['success_rate']:.2%}")
print(f"Average processing time: {stats['average_processing_time']:.3f}s")
# Reset statistics
processor.reset_statistics()
```
## 🔌 Extensibility
### Adding New Use Cases
1. **Create Use Case Class**:
```python
from matrice_analytics.post_processing.core.base import BaseProcessor
class MyCustomUseCase(BaseProcessor):
def __init__(self):
super().__init__("my_custom_usecase")
self.category = "custom"
def process(self, data, config, context=None):
# Implement your processing logic
return self.create_result(processed_data, "my_custom_usecase", "custom")
```
2. **Register Use Case**:
```python
from matrice_analytics.post_processing.core.base import registry
registry.register_use_case("custom", "my_custom_usecase", MyCustomUseCase)
```
### Adding New Utility Functions
Add utility functions to the appropriate module in the `utils/` directory and export them in `utils/__init__.py`.
## 🧪 Testing
The system includes comprehensive error handling and validation. Here's how to test your implementations:
```python
# Test configuration validation
errors = processor.validate_config({
'usecase': 'people_counting',
'confidence_threshold': 0.5
})
# Test with sample data
sample_data = [
{'category': 'person', 'confidence': 0.8, 'bbox': [10, 10, 50, 50]}
]
result = process_simple(sample_data, 'people_counting')
assert result.is_success()
```
## 🔄 Migration from Old System
If you're migrating from the old post-processing system:
1. **Update Imports**:
```python
# Old
from matrice_analytics.old_post_processing import some_function
# New
from matrice_analytics.post_processing import PostProcessor, process_simple
```
2. **Update Processing Calls**:
```python
# Old
result = old_process_function(data, config_dict)
# New
result = process_simple(data, "usecase_name", **config_dict)
```
3. **Update Configuration**:
```python
# Old
config = {"threshold": 0.5, "enable_tracking": True}
# New
config = processor.create_config("people_counting",
confidence_threshold=0.5,
enable_tracking=True)
```
## 🐛 Troubleshooting
### Common Issues
1. **Use Case Not Found**:
```python
# Check available use cases
print(processor.list_available_usecases())
```
2. **Configuration Validation Errors**:
```python
# Validate configuration
errors = processor.validate_config(config)
if errors:
print(f"Validation errors: {errors}")
```
3. **Processing Failures**:
```python
# Check result status and error details
if not result.is_success():
print(f"Error: {result.error_message}")
print(f"Error type: {result.error_type}")
print(f"Error details: {result.error_details}")
```
## 📝 API Reference
### Main Classes
- **`PostProcessor`**: Main processing class
- **`ProcessingResult`**: Standardized result container
- **`BaseConfig`**: Base configuration class
- **`PeopleCountingConfig`**: People counting configuration
- **`CustomerServiceConfig`**: Customer service configuration
### Convenience Functions
- **`process_simple()`**: Simple processing function
- **`create_config_template()`**: Get configuration template
- **`list_available_usecases()`**: List available use cases
- **`validate_config()`**: Validate configuration
### Utility Functions
The system provides comprehensive utility functions organized by category:
- **Geometry**: Point-in-polygon, distance calculations, IoU
- **Format**: Format detection and conversion
- **Filter**: Confidence filtering, deduplication
- **Counting**: Object counting, zone analysis
- **Tracking**: Movement analysis, line crossing detection
## 🎯 Best Practices
1. **Use Simple Processing for Quick Tasks**:
```python
result = process_simple(data, "people_counting", confidence_threshold=0.5)
```
2. **Use PostProcessor Class for Complex Workflows**:
```python
processor = PostProcessor()
config = processor.create_config("people_counting", **params)
result = processor.process(data, config)
```
3. **Always Check Result Status**:
```python
if result.is_success():
# Process successful result
else:
# Handle error
```
4. **Use Configuration Files for Complex Setups**:
```python
processor.save_config(config, "config.json")
result = processor.process_from_file(data, "config.json")
```
5. **Monitor Processing Statistics**:
```python
stats = processor.get_statistics()
# Monitor success rates and performance
```
## 🔮 Future Enhancements
The refactored system is designed for easy extension. Planned enhancements include:
- Additional use cases (security monitoring, retail analytics)
- Advanced tracking algorithms
- Real-time processing capabilities
- Integration with external analytics platforms
- Machine learning-based insights generation
---
**The refactored post-processing system provides a solid foundation for scalable, maintainable, and powerful analytics capabilities. The clean architecture makes it easy to extend and customize for specific use cases while maintaining consistency and reliability.**
| text/markdown | null | "Matrice.ai" <dipendra@matrice.ai> | null | null | null | matrice, common, utilities, pyarmor, obfuscated | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Operating System :: POSIX :: Linux",
"Operating System :: Microsoft :: Windows",
"Operating System :: MacOS",
"Topic :: Software Development :: Libraries :: Python Modules",
"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",
"Typing :: Typed"
] | [] | null | null | >=3.8 | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-20T13:56:10.393899 | matrice_analytics-0.1.174.tar.gz | 2,444,909 | de/bd/15ac66de4a4305a985012f10a52b52f570de961b91634f6cfa3861345815/matrice_analytics-0.1.174.tar.gz | source | sdist | null | false | be085299438014e7eba00bd63e1d67da | b49f6e043dcdae06097b7a15353dcf6a8f32ae9c320d2d8cd0270b072473a7c6 | debd15ac66de4a4305a985012f10a52b52f570de961b91634f6cfa3861345815 | MIT | [
"LICENSE.txt"
] | 24,072 |
2.3 | backgrounds | 0.1.4 | A set of tools for LISA stochastic gravitational wave detection | # backgrounds
A set tools for stochastic gravitational wave backgrounds data analysis.
## Documentation
A documentation is available on Github pages: https://qbaghi.pages.in2p3.fr/backgrounds
## Dependencies
Backgrounds requires LISA Constants and LISA GW Response from the LISA Simulation suite, which can be installed as
```
pip install git+https://@gitlab.in2p3.fr/lisa-simulation/constants.git@latest
pip install git+https://gitlab.in2p3.fr/lisa-simulation/gw-response.git@latest
```
To run the scripts in the tests folder it is recommanded to install the packages listed in the requirements:
```
pip install --no-cache-dir -r requirements.txt
```
## Installation
### Released version
Simply run
```
pip install backgrounds
```
### Development version
You need to be part of the LISA Consortium and have access to the IN2P3 Gitlab to access the
development version. This will change in the future.
Please clone the repository and do a manual installation:
```
git clone git@gitlab.in2p3.fr:qbaghi/backgrounds.git
cd backgrounds
pip install -e .
```
## Acknowledgements
If you are using backgrounds in your work, please cite
[this paper](https://iopscience.iop.org/article/10.1088/1475-7516/2023/04/066):
@article{Baghi_2023,
doi = {10.1088/1475-7516/2023/04/066},
url = {https://doi.org/10.1088/1475-7516/2023/04/066},
year = {2023},
month = {apr},
publisher = {IOP Publishing},
volume = {2023},
number = {04},
pages = {066},
author = {Baghi, Quentin and Karnesis, Nikolaos and Bayle, Jean-Baptiste and Besançon, Marc and Inchauspé, Henri},
title = {Uncovering gravitational-wave backgrounds from noises of unknown shape with LISA},
} | text/markdown | Quentin Baghi | quentin.baghi@protonmail.com | null | null | BSD-3-Clause | null | [
"License :: OSI Approved :: BSD License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | <4.0,>=3.12 | [] | [] | [] | [
"numpy>=2.3.1",
"scipy>=1.16.0",
"h5py>=3.14.0",
"pytest>=8.4.1",
"matplotlib>=3.10.3",
"lisaconstants>=2.0.1",
"lisaorbits>=3.0.2",
"lisagwresponse>=3.0.1",
"jax>=0.6.2",
"ipykernel>=6.29.5",
"interpax>=0.3.12"
] | [] | [] | [] | [] | poetry/2.1.3 CPython/3.13.3 Darwin/25.2.0 | 2026-02-20T13:56:02.466144 | backgrounds-0.1.4.tar.gz | 52,360 | de/93/17717b03a81c2ac39929dec82f93de12a5af822578b8adb67b8650276860/backgrounds-0.1.4.tar.gz | source | sdist | null | false | 30016b60a685b48daafc2762b923cf34 | c91383955def2ffc4e71003e2fdae4137cd47802c51fd7b77def3ae748f06a1f | de9317717b03a81c2ac39929dec82f93de12a5af822578b8adb67b8650276860 | null | [] | 208 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.