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 | danger-ffjwt | 1.1.0 | Free Fire JWT token conversion library | # danger-ffjwt
Free Fire token conversion library – easily convert between guest credentials, access tokens, EAT tokens, and JWT.
## Installation
```bash
pip install danger-ffjwt
| text/markdown | @danger_ff_like | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | https://github.com/yourusername/danger-ffjwt | null | >=3.6 | [] | [] | [] | [
"requests",
"pycryptodome",
"protobuf"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-18T10:34:41.454662 | danger_ffjwt-1.1.0.tar.gz | 7,048 | c4/51/e578b30ccfa353c6a0b7959a454d8b9e1d7f96a0ccab332f11b421e80a8c/danger_ffjwt-1.1.0.tar.gz | source | sdist | null | false | 40343e02f437d9b81a2e391640098994 | 87195182e6e95cb4f9e615bc1ad793d38180bcda1b0cf3dd4152be53d809b974 | c451e578b30ccfa353c6a0b7959a454d8b9e1d7f96a0ccab332f11b421e80a8c | null | [] | 351 |
2.3 | commitizen | 4.13.8 | Python commitizen client tool | [](https://github.com/commitizen-tools/commitizen/actions)
[](https://github.com/commitizen-tools/commitizen/actions/workflows/links.yml)
[](https://conventionalcommits.org)
[](https://pypi.org/project/commitizen/)
[](https://pypi.org/project/commitizen/)
[](https://pypi.org/project/commitizen/)
[](https://anaconda.org/conda-forge/commitizen)
[](https://formulae.brew.sh/formula/commitizen)
[](https://codecov.io/gh/commitizen-tools/commitizen)
[](https://github.com/j178/prek)
---
[**Commitizen Documentation Site**](https://commitizen-tools.github.io/commitizen/)
---
## About
Commitizen is a powerful release management tool that helps teams maintain consistent and meaningful commit messages while automating version management.
### What Commitizen Does
By enforcing standardized commit conventions (defaulting to [Conventional Commits][conventional_commits]), Commitizen helps teams:
- Write clear, structured commit messages
- Automatically manage version numbers using semantic versioning
- Generate and maintain changelogs
- Streamline the release process
### Key Benefits
With just a simple `cz bump` command, Commitizen handles:
1. **Version Management**: Automatically bumps version numbers and updates version files based on your commit history
2. **Changelog Generation**: Creates and updates changelogs following the [Keep a changelog][keepchangelog] format
3. **Commit Standardization**: Enforces consistent commit message formats across your team
This standardization makes your commit history more readable and meaningful, while the automation reduces manual work and potential errors in the release process.
### Features
- Interactive CLI for standardized commits with default [Conventional Commits][conventional_commits] support
- Intelligent [version bumping](https://commitizen-tools.github.io/commitizen/commands/bump/) using [Semantic Versioning][semver]
- Automatic [keep a changelog][keepchangelog] generation
- Built-in commit validation with pre-commit hooks
- [Customizable](https://commitizen-tools.github.io/commitizen/customization/config_file/) commit rules and templates
- Multi-format version file support
- Custom rules and plugins via pip
## Getting Started
### Requirements
Before installing Commitizen, ensure you have:
- [Python](https://www.python.org/downloads/) `3.10+`
- [Git][gitscm] `1.8.5.2+`
### Installation
#### Global Installation (Recommended)
The recommended way to install Commitizen is using [`pipx`](https://pipx.pypa.io/) or [`uv`](https://docs.astral.sh/uv/), which ensures a clean, isolated installation:
**Using pipx:**
```bash
# Install Commitizen
pipx install commitizen
# Keep it updated
pipx upgrade commitizen
```
**Using uv:**
```bash
# Install commitizen
uv tool install commitizen
# Keep it updated
uv tool upgrade commitizen
```
**(For macOS users) Using Homebrew:**
```bash
brew install commitizen
```
#### Project-Specific Installation
You can add Commitizen to your Python project using any of these package managers:
**Using pip:**
```bash
pip install -U commitizen
```
**Using conda:**
```bash
conda install -c conda-forge commitizen
```
**Using Poetry:**
```bash
# For Poetry >= 1.2.0
poetry add commitizen --group dev
# For Poetry < 1.2.0
poetry add commitizen --dev
```
**Using uv:**
```bash
uv add --dev commitizen
```
**Using pdm:**
```bash
pdm add -d commitizen
```
### Basic Commands
#### Initialize Commitizen
To get started, run the `cz init` command. This will guide you through the process of creating a configuration file with your preferred settings.
#### Create Commits
Create standardized commits using:
```sh
cz commit
# or use the shortcut
cz c
```
To sign off your commits:
```sh
cz commit -- --signoff
# or use the shortcut
cz commit -- -s
```
For more commit options, run `cz commit --help`.
#### Version Management
The most common command you'll use is:
```sh
cz bump
```
This command:
- Bumps your project's version
- Creates a git tag
- Updates the changelog (if `update_changelog_on_bump` is enabled)
- Updates version files
You can customize:
- [Version files](https://commitizen-tools.github.io/commitizen/commands/bump/#version_files)
- [Version scheme](https://commitizen-tools.github.io/commitizen/commands/bump/#version_scheme)
- [Version provider](https://commitizen-tools.github.io/commitizen/config/version_provider/)
For all available options, see the [bump command documentation](https://commitizen-tools.github.io/commitizen/commands/bump/).
### Advanced Usage
#### Get Project Version
```sh
# Get your project's version (instead of Commitizen's version)
cz version -p
# Preview changelog changes
cz changelog --dry-run "$(cz version -p)"
```
This command is particularly useful for automation scripts and CI/CD pipelines.
For example, you can use the output of the command `cz changelog --dry-run "$(cz version -p)"` to notify your team about a new release in Slack.
#### Prek and Pre-commit Integration
Commitizen can automatically validate your commit messages using pre-commit hooks.
1. Add to your `.pre-commit-config.yaml`:
```yaml
---
repos:
- repo: https://github.com/commitizen-tools/commitizen
rev: master # Replace with latest tag
hooks:
- id: commitizen
- id: commitizen-branch
stages: [pre-push]
```
2. Install the hooks:
```sh
prek install --hook-type commit-msg --hook-type pre-push
```
| Hook | Recommended Stage |
| ----------------- | ----------------- |
| commitizen | commit-msg |
| commitizen-branch | pre-push |
> **Note**: Replace `master` with the [latest tag](https://github.com/commitizen-tools/commitizen/tags) to avoid warnings. You can automatically update this with:
> ```sh
> prek autoupdate
> ```
For more details about commit validation, see the [check command documentation](https://commitizen-tools.github.io/commitizen/commands/check/).
## Help & Reference
### Command Line Interface
Commitizen provides a comprehensive CLI with various commands. Here's the complete reference:
### Quick Reference
| Command | Description | Alias |
|---------|-------------|-------|
| `cz init` | Initialize Commitizen configuration | - |
| `cz commit` | Create a new commit | `cz c` |
| `cz bump` | Bump version and update changelog | - |
| `cz changelog` | Generate changelog | `cz ch` |
| `cz check` | Validate commit messages | - |
| `cz version` | Show version information | - |
### Additional Resources
- [Conventional Commits Specification][conventional_commits]
- [Exit Codes Reference](https://commitizen-tools.github.io/commitizen/exit_codes/)
- [Configuration Guide](https://commitizen-tools.github.io/commitizen/config/configuration_file/)
- [Command Documentation](https://commitizen-tools.github.io/commitizen/commands/init/)
### Getting Help
For each command, you can get detailed help by adding `--help`:
```sh
cz commit --help
cz bump --help
cz changelog --help
```
For more details, visit our [documentation site](https://commitizen-tools.github.io/commitizen/).
## Setting up bash completion
Commitizen supports command-line completion through [argcomplete](https://kislyuk.github.io/argcomplete/), which is automatically installed as a dependency. This feature provides intelligent auto-completion for all Commitizen commands and options.
### Supported Shells
- **Bash**: Full support
- **Zsh**: Limited support
- **Fish**: Limited support
- **Tcsh**: Limited support
### Installation Methods
#### Global Installation (Recommended)
If you installed Commitizen globally (e.g., using `pipx` or `brew`), you can enable global completion:
```bash
# Enable global completion for all Python applications
sudo activate-global-python-argcomplete
```
#### User-Specific Installation
For a user-specific installation that persists across sessions:
```bash
# Add to your shell's startup file (e.g., ~/.bashrc, ~/.zshrc)
register-python-argcomplete cz >> ~/.bashrc
```
#### Temporary Installation
For one-time activation in your current shell session:
```bash
# Activate completion for current session only
eval "$(register-python-argcomplete cz)"
```
### Verification
After installation, you can verify the completion is working by:
1. Opening a new terminal session
2. Typing `cz` followed by a space and pressing `TAB` twice
3. You should see a list of available commands
For more detailed information about argcomplete configuration and troubleshooting, visit the [argcomplete documentation](https://kislyuk.github.io/argcomplete/).
## Star History
[](https://star-history.com/#commitizen-tools/commitizen)
## Sponsors
These are our cool sponsors!
<!-- sponsors --><!-- sponsors -->
[conventional_commits]: https://www.conventionalcommits.org
[semver]: https://semver.org/
[keepchangelog]: https://keepachangelog.com/
[gitscm]: https://git-scm.com/downloads
| text/markdown | Santiago Fraire | Santiago Fraire <santiwilly@gmail.com> | Wei Lee, Axel H., Tim Hsiung | Wei Lee <weilee.rx@gmail.com>, Axel H. <noirbizarre@gmail.com>, Tim Hsiung <bear890707@gmail.com> | MIT License
Copyright (c) 2017 Santiago
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. | commitizen, conventional, commits, git | [
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: Developers",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Program... | [] | null | null | <4.0,>=3.10 | [] | [] | [] | [
"questionary<3.0,>=2.0",
"prompt-toolkit!=3.0.52",
"decli<1.0,>=0.6.0",
"colorama<1.0,>=0.4.1",
"termcolor<4.0.0,>=1.1.0",
"packaging>=19",
"tomlkit<1.0.0,>=0.8.0",
"jinja2>=2.10.3",
"pyyaml>=3.8",
"argcomplete<3.7,>=1.12.1",
"typing-extensions<5.0.0,>=4.0.1; python_full_version < \"3.11\"",
"... | [] | [] | [] | [
"Homepage, https://github.com/commitizen-tools/commitizen",
"Documentation, https://commitizen-tools.github.io/commitizen/",
"Repository, https://github.com/commitizen-tools/commitizen",
"Issues, https://github.com/commitizen-tools/commitizen/issues",
"Changelog, https://github.com/commitizen-tools/commitiz... | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:33:14.670457 | commitizen-4.13.8.tar.gz | 64,155 | 6f/8a/73c165b1c7b182f506208c959e0ac56c844eccdbbfc0fa4f23a2fa9aa6b7/commitizen-4.13.8.tar.gz | source | sdist | null | false | 60f9956a530520d4e23ad7c5bf653b78 | d8769c0b2ee7bfe15d6871af1e242913df696b4a94e91a8146c5d78b778144ee | 6f8a73c165b1c7b182f506208c959e0ac56c844eccdbbfc0fa4f23a2fa9aa6b7 | null | [] | 101,084 |
2.4 | nomenclature-iamc | 0.29.2 | Package for managing codelists & attributes for IAMC-format datasets | # nomenclature - Working with IAMC-format project definitions
Copyright 2021-2023 IIASA
This repository is licensed under the Apache License, Version 2.0 (the "License"); see
the [LICENSE](LICENSE) for details.
[](https://github.com/IAMconsortium/nomenclature/blob/main/LICENSE)
[](https://zenodo.org/badge/latestdoi/375724610)
[](https://github.com/IAMconsortium/nomenclature)
[](https://github.com/astral-sh/ruff)
[](https://github.com/IAMconsortium/nomenclature/actions/workflows/pytest.yml)
[](https://nomenclature-iamc.readthedocs.io)
## Overview
The **nomenclature** package facilitates validation and processing of scenario data.
It allows managing definitions of data structures for model comparison projects and
scenario analysis studies using the data format developed by the
[Integrated Assessment Modeling Consortium (IAMC)](https://www.iamconsortium.org).
A data structure definition consists of one or several "codelists".
A codelist is a list of allowed values (or "codes") for dimensions of IAMC-format data,
typically *regions* and *variables*. Each code can have additional attributes:
for example, a "variable" has to have an expected unit and usually has a description.
Read the [SDMX Guidelines](https://sdmx.org/?page_id=4345) for more information on
the concept of codelists.
The **nomenclature** package supports three main use cases:
- Management of codelists and mappings for model comparison projects
- Validation of scenario data against the codelists of a specific project
- Processing of scenario results, e.g. aggregation and renaming from "native regions" of
a model to "common regions" (i.e., regions that are used for scenario comparison in a project).
The documentation is hosted on [Read the Docs](https://nomenclature-iamc.readthedocs.io/).
## Integration with the pyam package
<img src="https://github.com/IAMconsortium/pyam/blob/main/docs/logos/pyam-logo.png"
width="133" height="100" align="right" alt="pyam logo" />
The **nomenclature** package is designed to complement the Python package **pyam**,
an open-source community toolbox for analysis & visualization of scenario data.
The **pyam** package was developed to facilitate working with timeseries scenario data
conforming to the format developed by the IAMC. It is used in ongoing assessments by
the IPCC and in many model comparison projects at the global and national level,
including several Horizon 2020 & Horizon Europe projects.
The validation and processing features of the **nomenclature** package
work with scenario data as a [**pyam.IamDataFrame**](https://pyam-iamc.readthedocs.io/en/stable/api/iamdataframe.html) object.
[Read the **pyam** Docs](https://pyam-iamc.readthedocs.io) for more information!
## Getting started
To install the latest release of the package, please use the following command:
```bash
pip install nomenclature-iamc
```
Alternatively, it can also be installed directly from source:
```bash
pip install -e git+https://github.com/IAMconsortium/nomenclature#egg=nomenclature-iamc
```
See the [User Guide](https://nomenclature-iamc.readthedocs.io/en/latest/user_guide.html)
for the main use cases of this package.
## Acknowledgement
<img src="./docs/_static/open_entrance-logo.png" width="202" height="129"
align="right" alt="openENTRANCE logo" />
This package is based on the work initially done in the [Horizon 2020
openENTRANCE](https://openentrance.eu) project, which aims to develop, use and
disseminate an open, transparent and integrated modelling platform for assessing
low-carbon transition pathways in Europe.
Refer to the [openENTRANCE/openentrance](https://github.com/openENTRANCE/openentrance)
repository for more information.
<img src="./docs/_static/EU-logo-300x201.jpg" width="80" height="54" align="left"
alt="EU logo" /> This project has received funding from the European Union’s Horizon
2020 research and innovation programme under grant agreement No. 835896.
| text/markdown | Scenario Services team, ECE program, IIASA | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13"
] | [] | null | null | <3.14,>=3.11 | [] | [] | [] | [
"PyYAML<7.0,>=6.0.1",
"gitpython<4.0,>=3.1.40",
"numpy<3.0,>=1.23.0",
"openpyxl<4.0,>=3.1.2",
"pandas<3.0,>=1.5.2",
"pyam-iamc<4.0,>=3.1",
"pycountry==23.12.11",
"pydantic<3,>=2",
"pysquirrel<2.0,>=1.1",
"scse-toolkit<0.16.0,>=0.14.0",
"typer<0.21.0,>=0.20.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:33:07.710980 | nomenclature_iamc-0.29.2.tar.gz | 44,866 | e3/48/6c29210df6a18dc2d3a4e2bda6763af7a3814963bb4ca38911a59f8b0d75/nomenclature_iamc-0.29.2.tar.gz | source | sdist | null | false | 29e90611a0907e3fa6d02bb5445cf792 | b62148fa6e054745e10035564a17ec8bed0f2f160ffaec1b7465c3643f80710c | e3486c29210df6a18dc2d3a4e2bda6763af7a3814963bb4ca38911a59f8b0d75 | Apache-2.0 | [
"LICENSE"
] | 357 |
2.4 | uns-kit | 0.0.31 | Lightweight Python UNS MQTT client (pub/sub + infra topics) | # uns-kit (Python)
Lightweight UNS MQTT client for Python. Provides:
- Topic builder compatible with UNS infra topics (`uns-infra/<package>/<version>/<process>/`).
- Async publish/subscribe via MQTT (using `aiomqtt`).
- Process + instance status topics (active/heap/uptime/alive + stats).
- Minimal UNS packet builder/parser (data/table) aligned with TS core.
## Install (editable)
```bash
cd packages/uns-py
poetry install
```
## CLI
After `poetry install`, an `uns-kit-py` command is available (renamed to avoid clashing with the Node CLI):
```bash
poetry run uns-kit-py publish --host localhost:1883 --topic raw/data/ --value 1
poetry run uns-kit-py subscribe --host localhost:1883 --topic 'uns-infra/#'
```
## Quick start
```python
import asyncio
from pathlib import Path
from uns_kit import ConfigFile, UnsPacket, UnsProcessParameters, UnsProxyProcess
async def main():
config = ConfigFile.load_config(Path("config.json"))
infra = config["infra"]
uns = config["uns"]
process = UnsProxyProcess(
infra["host"],
UnsProcessParameters(process_name=uns.get("processName", "uns-process")),
)
await process.start()
mqtt = await process.create_mqtt_proxy("py")
# Subscribe
async with mqtt.client.messages("uns-infra/#") as messages:
await mqtt.publish_packet("raw/data/", UnsPacket.data(value=1, uom="count"))
msg = await messages.__anext__()
print(msg.topic, msg.payload.decode())
await mqtt.close()
await process.stop()
asyncio.run(main())
```
## Config placeholders (env + Infisical)
`uns-py` now resolves config placeholders in the same style as `uns-core`.
For Infisical placeholders, install the optional extra:
```bash
pip install "uns-kit[infisical]"
```
Example `config.json`:
```json
{
"uns": {
"graphql": "https://example/graphql",
"rest": "https://example/rest",
"email": "service@example.com",
"password": { "provider": "env", "key": "UNS_PASSWORD" },
"processName": "my-process"
},
"infra": {
"host": "mqtt.example.local",
"port": 1883,
"username": "mqtt-user",
"password": {
"provider": "infisical",
"path": "/mqtt",
"key": "password",
"environment": "dev"
}
}
}
```
Load resolved config with cache semantics:
```python
from uns_kit import ConfigFile, SecretResolverOptions, InfisicalResolverOptions
resolved = ConfigFile.load_config(
"config.json",
SecretResolverOptions(
infisical=InfisicalResolverOptions(
environment="dev",
project_id="your-project-id"
)
)
)
```
### Resilient subscriber
```python
async for msg in client.resilient_messages("uns-infra/#"):
print(msg.topic, msg.payload.decode())
```
### Examples
- `examples/publish.py` — publish 5 data packets.
- `examples/subscribe.py` — resilient subscription with auto-reconnect.
- `examples/load_test.py` — interactive publish burst.
### Create a new project
```bash
uns-kit-py create my-uns-py-app
cd my-uns-py-app
poetry install
poetry run python src/main.py
```
### Create a sandbox app in this repo
From the monorepo root:
```bash
pnpm run py:sandbox
```
This creates `sandbox-app-py/` using the default Python template.
When created inside this monorepo, `pyproject.toml` is automatically set to use local editable `uns-kit`:
`uns-kit = { path = "../packages/uns-py", develop = true }`.
## Notes
- Default QoS is 0.
- Instance status topics are published every 10 seconds; stats every 60 seconds.
- Packet shape mirrors the TypeScript core: `{"version":"1.3.0","message":{"data":{...}},"sequenceId":0}`.
- Windows: the library sets `WindowsSelectorEventLoopPolicy()` to avoid `add_reader/add_writer` `NotImplementedError`.
## TODO (parity with TS core)
- Handover manager (cross-version active detection + handover_* messages).
- Publish throttling/queue.
- Status parity (publisher/subscriber active flags everywhere, richer metrics).
- API endpoints registry (to mirror @uns-kit/api produced endpoints).
- Optional: dictionary/measurement helpers + CLI wrapper.
| text/markdown | Aljoša Vister | aljosa.vister@gmail.com | 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 | [] | [] | [] | [
"aiomqtt<3.0.0,>=2.4.0",
"click<9.0.0,>=8.1.7",
"infisicalsdk<2.0.0,>=1.0.15; extra == \"infisical\""
] | [] | [] | [] | [] | poetry/2.3.2 CPython/3.11.5 Windows/10 | 2026-02-18T10:32:54.747043 | uns_kit-0.0.31-py3-none-any.whl | 39,801 | 0a/61/8526bdbb022144d687840a19cd92bd5376c0de515ca2bf35af629338a5ba/uns_kit-0.0.31-py3-none-any.whl | py3 | bdist_wheel | null | false | 560ea18c936f3e2a9609f8771fbfa959 | 9f4270f1f718d48860455e2bafa9e8214d33ad3a2146a0250aedf076efbcb6fb | 0a618526bdbb022144d687840a19cd92bd5376c0de515ca2bf35af629338a5ba | null | [] | 249 |
2.4 | grammar-utils | 0.1.4 | Utilities for regex and grammar parsing and constraining | ## Grammar utilities
This repository contains Python utilities (backed by Rust) to parse and constrain text with regular expressions
and context-free grammars (LR(1)). Parsing is supported both for prefixes and full strings.
Context-free [grammars](grammars) already included in this repository are:
- JSON
- SPARQL
### Installation
You can install the Python package from PyPI:
```bash
pip install grammar-utils
```
Only Linux is currently supported when installing from PyPI. Windows is causing some issues in CI so builds for this platform are not yet available.
Alternatively, you can clone this repository and build the package yourself:
```bash
git clone https://github.com/bastiscode/grammar-utils
cd grammar-utils
pip install maturin[patchelf]
maturin develop --release
```
### Usage
Two use cases are supported by this library: parsing and constraining.
#### Parsing
Given a context-free grammar, parse a string and return the corresponding parse tree.
```python
from grammar_utils.parse import load_lr1_parser
parser = load_lr1_parser("json")
tree = parser.parse('{"key": "value"}')
print(tree)
# you can calso get a pruned parse tree, skipping empty or collapsing single child nodes
pruned_tree = parser.parse('{"key": "value"}', skip_empty=True, collapse_single=True)
print(pruned_tree)
```
Parsing is also supported for prefixes, in which case the input should be a list of bytes
and not a string. Here a tree for the already fixed terminals is returned, as well as the
suffix of the input where we do not know yet what the next terminal is.
```python
from grammar_utils.parse import load_lr1_parser
parser = load_lr1_parser("json")
tree, rest = parser.prefix_parse(b'{"key"")
print(tree)
print(rest)
# pruning is also supported here
pruned_tree, rest = parser.prefix_parse(b'{"key"', skip_empty=True, collapse_single=True)
print(pruned_tree)
print(rest)
```
You can also use your own grammars.
```python
from grammar_utils.parse import LR1Parser
# define your own grammar and lexer
grammar = "..."
lexer = "..."
parser = LR1Parser(grammar, lexer, vocab)
```
#### Constraining
Constraints are used to check what symbols from the vocabulary can follow the current prefix
such that the regular expression or context-free grammar can still be satisfied.
```python
import random
from grammar_utils import load_byte_vocab
from grammar_utils.constrain import load_lr1_constraint, load_regex_constraint
vocab = load_byte_vocab()
constraint = load_lr1_constraint("json", vocab)
# reset constraint to a given prefix, default is an empty prefix
constraint.reset(b'{"key"')
# get the next possible symbols
next_indices = constraint.get()
# the indices refer to the vocabulary (decode only for human-readable strings)
print(f"allowed continuations: {[bytes(vocab[i]).decode() for i in next_indices]}")
# you can forward the constraint with a valid index
constraint.next(random.choice(next_indices))
# check if constraint is satisfied (should be False)
print(constraint.is_match())
# same for regular expressions
constraint = load_regex_constraint("boolean", vocab)
constraint.reset(b"tr")
next_indices = constraint.get()
# should only be 'u'
print(f"allowed continuations: {[bytes(vocab[i]).decode() for i in next_indices]}")
constraint.next(next_indices[0])
print(constraint.is_match())
next_indices = constraint.get()
# should only be 'e'
print(f"allowed continuations: {[bytes(vocab[i]).decode() for i in next_indices]}")
constraint.next(next_indices[0])
# should be True
print(constraint.is_match())
```
You can also use your own grammars and regexes.
```python
from grammar_utils import load_byte_vocab
from grammar_utils.constrain import LR1Constraint, RegexConstraint
vocab = load_byte_vocab()
# define your own grammar and lexer
grammar = "..."
lexer = "..."
constraint = LR1Constraint(grammar, lexer, vocab)
# define your own regex
regex = "..."
constraint = RegexConstraint(regex, vocab)
```
### Use cases
#### Forcing a language model to generate structured text
The following example shows how to use a regex constraint to force GPT2
to output either "true" or "false" after a given prompt.
```python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from grammar_utils.constrain import load_regex_constraint
gpt2 = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
vocab = [
token.replace("Ġ", " ").encode()
for token, _ in sorted(tokenizer.get_vocab().items(), key=lambda x: x[1])
]
constraint = load_regex_constraint("boolean", vocab)
prefix = "Constrained decoding is cool: "
input_ids = tokenizer.encode(prefix)
while not (constraint.is_match() or constraint.is_invalid()):
input_tensor = torch.tensor([input_ids])
logits = gpt2(input_tensor).logits
valid_indices = torch.from_numpy(constraint.get())
valid_logits = logits[0, -1, valid_indices]
index = valid_indices[torch.argmax(valid_logits)]
constraint.next(index)
input_ids.append(index)
print(tokenizer.decode(input_ids))
```
| text/markdown; charset=UTF-8; variant=GFM | null | Sebastian Walter <swalter@cs.uni-freiburg.de> | null | null | null | nlp, utilities, text, grammar, constraint | [
"Programming Language :: Rust",
"Programming Language :: Python :: 3",
"Topic :: Software Development :: Libraries",
"Topic :: Text Processing",
"Topic :: Utilities"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"numpy>=1.26"
] | [] | [] | [] | [
"Github, https://github.com/bastiscode/grammar-utils"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:32:33.185015 | grammar_utils-0.1.4.tar.gz | 180,489 | 1e/3b/44273e2a14db965970989a3413016f463f1f26cf654f3b84d185e1edb7b5/grammar_utils-0.1.4.tar.gz | source | sdist | null | false | bc898f69996442ef48f816a510a9fcd9 | 677b3b9ddd836f6dced5a43e0a7b2ac7205ff2a6d75aa4617afcadca4ac1e244 | 1e3b44273e2a14db965970989a3413016f463f1f26cf654f3b84d185e1edb7b5 | null | [
"LICENSE"
] | 475 |
2.1 | huntd | 0.6.1 | Your coding fingerprint — local git analytics dashboard for all your repos. | <div align="center">
# 🐺 huntd
**Your coding fingerprint — local git analytics dashboard for all your repos.**
[](https://pypi.org/project/huntd/)
[](https://pypi.org/project/huntd/)
</div>
---
Scan every git repo on your machine. Get streaks, heatmaps, language trends, project health scores, and more — all in one interactive terminal dashboard.
> WakaTime costs $9/mo. GitHub Wrapped is once a year. **huntd** is free, local, instant, and sees everything.
## Install
```bash
pip install huntd
```
## Quick Start
```bash
# Interactive TUI dashboard
huntd ~/code
# One-shot summary (no TUI)
huntd ~/code --summary
# JSON output (pipe to jq, scripts, etc.)
huntd ~/code --json
# Scan current directory
huntd
```
## Filtering
Slice your data by time, author, or compare directories.
```bash
# Only commits from 2025
huntd ~/code --summary --since 2025-01-01 --until 2025-12-31
# Only your commits in team repos
huntd ~/code --summary --author "Joe"
# Last 3 months
huntd ~/code --summary --since "3 months ago"
# Compare two directories side by side
huntd --compare ~/work ~/personal --summary
# Filters work with all modes
huntd ~/code --json --author "Joe" --since 2025-01-01
```
## Sharing & Export
```bash
# Spotify Wrapped-style SVG card
huntd ~/code --wrapped
# Clean markdown report (for Notion, blogs, performance reviews)
huntd ~/code --report
# SVG badge for GitHub profile READMEs
huntd ~/code --badge
# Combine with filters
huntd ~/code --wrapped --since 2025-01-01
# Generate all three at once
huntd ~/code --wrapped --report --badge
```
## Live Mode
Keep the dashboard running and watch it update as you commit.
```bash
# Auto-refresh dashboard every 30 seconds
huntd ~/code --watch
# Custom interval (seconds)
huntd ~/code --watch --interval 60
# Toggle watch on/off inside the TUI with 'w'
# Press 'w' to start/stop live refresh anytime
# Install post-commit hooks across all repos
huntd ~/code --install-hook
```
## What You Get
```
_ _ _
| |__ _ _ _ __| |_ __| |
| '_ \| | | | '_ \ __/ _` |
| | | | |_| | | | | || (_| |
|_| |_|\__,_|_| |_|\__\__,_|
your coding fingerprint
╭────────────────────────────────── 🐺 huntd ──────────────────────────────────╮
│ │
│ 14 repos 4,847 commits 8 languages │
│ 🔥 14 day streak 🏆 31 longest │
│ 📅 Tuesdays at 10pm ⚡ 3.2/day │
│ 📊 ▁▃▅█▆▃▂ Mon→Sun │
│ │
╰──────────────────────────────────────────────────────────────────────────────╯
──────────────────────────── 📊 Contributions ─────────────────────────────────
Mon ░░▒▓█▒░░▒▒▓▓█░░░▒▒▓█▒░░░░▒▒▓▓████▒▒░░░
Tue ░▒▓█▒░░░▒▒▓▓█░░░▒▒▓▓█▒░░░░▒▓▓████▓▒░░░
Wed ░▒▒▓░░░░▒▒▓█▒░░░▒▒▓▓░░░░░▒▒▓████▓▒░░░░
Thu ░░▒▓█▒░▒▒▓▓█░░░▒▒▓█▒░░░░▒▒▓▓████▒▒░░░░
Fri ░░▒▒░░░░▒▒▓░░░░░▒▒▓▒░░░░░▒▒▓███▓▒░░░░░
Sat ░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▒░░░░░░
Sun ░░░░░░░░░▒▒░░░░░░▒░░░░░░░░░▒▓▓▒░░░░░░░
──────────────────────────── 📦 Repositories ──────────────────────────────────
┏━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━┓
┃ Repo ┃ Commits ┃ Language ┃ Health ┃ +Lines ┃ -Lines ┃
┡━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━┩
│ cloud-dash │ 847 │ Python │ █████████░ 95 │ +15,847 │ -1,204 │
│ pulse-mobile │ 623 │ Go │ ████████░░ 85 │ +8,619 │ -820 │
│ data-engine │ 412 │ Rust │ ████████░░ 80 │ +6,074 │ -503 │
│ api-gateway │ 203 │ TypeScript│ ███████░░░ 70 │ +2,876 │ -118 │
└──────────────┴─────────┴───────────┴───────────────┴─────────┴────────┘
───────────────────────────── 🔤 Languages ────────────────────────────────────
┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Language ┃ Lines Changed ┃ ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ Python │ 15,823 │ ████████████████████ 62% │
│ Go │ 5,628 │ ███████░░░░░░░░░░░░░ 22% │
│ Rust │ 2,519 │ ███░░░░░░░░░░░░░░░░░ 9% │
│ TypeScript │ 827 │ █░░░░░░░░░░░░░░░░░░░ 3% │
└────────────┴───────────────┴───────────────────────────┘
───────────────────────────── ⚡ Activity ─────────────────────────────────────
╭──────────────────────────────────────────────────────────────────────────────╮
│ 📅 Busiest day: Tuesday ⏰ Busiest hour: 10pm ⚡ Avg: 3.2/day │
│ 📊 Hourly: ▁▁▁▁▁▁▂▃▄▅▃▃▅▆▅▆▃▂▃▅▆█▇▂ 0h→23h │
╰──────────────────────────────────────────────────────────────────────────────╯
──────────────────────────── 📈 Velocity ────────────────────────────────────
╭──────────────────────────────────────────────────────────────────────────────╮
│ ▂▃▅▃▄▆▅▇█▆▅▃ (↑ up) Peak: 2025-W42 (27 commits) │
╰──────────────────────────────────────────────────────────────────────────────╯
────────────────────────── 📈 Language Evolution ────────────────────────────
┏━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━┓
┃ Language ┃ 2025-01 ┃ 2025-02 ┃ 2025-03 ┃ 2025-04 ┃ 2025-05 ┃ 2025-06 ┃ Trend ┃
┡━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━┩
│ Python │ 2,410 │ 1,850 │ 3,200 │ 2,900 │ 4,100 │ 3,800 │ ▂▁▄▃▆█│
│ Go │ 820 │ 640 │ 900 │ 1,100 │ 750 │ 680 │ ▅▃▆█▄▃│
│ TypeScript │ - │ 120 │ 450 │ 800 │ 1,200 │ 1,500 │ ▁▁▂▄▆█│
└────────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴───────┘
─────────────────────────── 🎯 Focus Score ──────────────────────────────────
╭──────────────────────────────────────────────────────────────────────────────╮
│ Avg repos/day: 2.3 [balanced] │
│ Most focused: 2025-04-12 Most scattered: 2025-06-01 │
╰──────────────────────────────────────────────────────────────────────────────╯
────────────────────────── 📅 Weekday vs Weekend ────────────────────────────
╭──────────────────────────────────────────────────────────────────────────────╮
│ Weekday: 78.4% (3,802 commits, +42,190 lines) │
│ Weekend: 21.6% (1,045 commits, +11,830 lines) │
╰──────────────────────────────────────────────────────────────────────────────╯
──────────────────────────── 🔥 File Hotspots ───────────────────────────────
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
┃ File ┃ Churn ┃ Touches ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
│ cloud-dash/src/dashboard.py │ 4,210 │ 47 │
│ pulse-mobile/pkg/api/handler.go │ 2,830 │ 31 │
│ data-engine/src/pipeline.rs │ 1,950 │ 22 │
│ api-gateway/src/routes/index.ts │ 1,120 │ 18 │
└───────────────────────────────────┴─────────┴─────────┘
──────────────── 🏆 Achievements (4/10) ─────────────────
╭──────────────────────────────────────────────────────────────────────────────╮
│ 💯 Century 100-day coding streak │
│ 📝 Prolific 1,000+ total commits │
│ 🌍 Polyglot 5+ languages with 100+ lines each │
│ 📦 Diversified 10+ active repos │
│ 🔒 Marathon 365-day coding streak │
│ 🔒 Night Owl 50%+ commits after midnight │
│ 🔒 Early Bird 50%+ commits before 9am │
│ 🔒 Weekend Warrior 40%+ commits on weekends │
│ 🔒 Monorepo Monster Single repo with 500+ commits │
│ 🔒 Clean Freak All repos have health score 80+ │
╰──────────────────────────────────────────────────────────────────────────────╯
```
## Features
| Feature | Description |
|---------|-------------|
| **Multi-repo scanning** | Recursively finds every git repo under a directory |
| **Coding streaks** | Current and longest streak computed from local commits |
| **Contribution heatmap** | GitHub-style green activity grid across all repos |
| **Language breakdown** | Lines changed per language with colored trend bars |
| **Project health scores** | 0-100 score with colored bars (green/yellow/red) |
| **Activity patterns** | Busiest day, busiest hour, sparklines, average commits per day |
| **Top repos ranking** | Sorted by commit count with language and health |
| **Interactive TUI** | Navigate panels with keyboard (Textual-powered) |
| **Summary mode** | `--summary` for a styled Rich-formatted printout |
| **JSON export** | `--json` for scripting, pipelines, and integrations |
| **Date filtering** | `--since` and `--until` to scope commits to a time window |
| **Author filtering** | `--author` to filter by committer name or email |
| **Compare mode** | `--compare` two directories side by side |
| **Code velocity** | Weekly commit trends with sparkline and up/down/stable indicator |
| **Language evolution** | Monthly language mix over time — see how your stack shifts |
| **Focus score** | Unique repos per day — deep focus vs scattered work patterns |
| **Weekday vs weekend** | Split activity by work days vs weekends with percentages |
| **File hotspots** | Most-churned files across all repos (find your messiest code) |
| **Achievements** | 10 unlockable badges — Century, Polyglot, Night Owl, and more |
| **Wrapped card** | `--wrapped` generates a Spotify Wrapped-style SVG card |
| **Markdown report** | `--report` exports a clean report for Notion, blogs, reviews |
| **Profile badge** | `--badge` generates an SVG badge for GitHub READMEs |
| **Live mode** | `--watch` auto-refreshes the dashboard as you commit |
| **Custom interval** | `--interval N` sets refresh frequency in seconds |
| **Git hooks** | `--install-hook` adds post-commit hooks to all scanned repos |
## How It Works
1. **Scan** — Recursively finds all `.git` directories under the target path
2. **Extract** — Runs optimized `git log` commands in parallel (8 threads) across all repos
3. **Analyze** — Computes streaks, heatmaps, language stats, health scores, and activity patterns
4. **Display** — Renders an interactive dashboard or summary
All data comes from local git history. No API keys. No accounts. No cloud. No cost.
## Output Modes
```bash
# Interactive dashboard (default)
huntd ~/code
# Static summary — great for screenshots
huntd ~/code --summary
# JSON — pipe to jq, save to file, feed to scripts
huntd ~/code --json
huntd ~/code --json | jq '.repos[] | select(.commits > 100)'
# Compare two directories
huntd --compare ~/work ~/personal --summary
huntd --compare ~/work ~/personal --json
# Version
huntd --version
```
## Health Score
Each repo gets a 0-100 health score based on:
| Factor | Points | Criteria |
|--------|--------|----------|
| Commit recency | 0-40 | Last commit within 7d (40), 30d (30), 90d (20), 1yr (10) |
| Total commits | 0-20 | 100+ (20), 50+ (15), 10+ (10), 1+ (5) |
| Has README | 0-15 | README file present in repo root |
| Branch hygiene | 0-15 | 1-5 branches (15), 6-10 (10), 11+ (5) |
| Clean tree | 0-10 | No uncommitted changes |
## Why Not X?
| Tool | Limitation |
|------|-----------|
| **WakaTime** | Cloud-only, $9/mo, tracks editor time not git history |
| **GitHub Wrapped** | Annual only, GitHub repos only, no local/private repos |
| **onefetch** | Single repo snapshot, not interactive |
| **git-quick-stats** | Single repo, text dump, no dashboard |
| **tokei / scc** | Line counting only, no history or trends |
**huntd** is the first tool to combine multi-repo scanning + streaks + heatmaps + language trends + health scores in one interactive dashboard. Free. Local. Instant.
## Development
```bash
git clone https://github.com/TRINITY-21/huntd.git
cd huntd
pip install -e ".[dev]"
python -m pytest tests/ -v
```
## Support
If this project is useful to you, consider supporting it.
<a href="https://buymeacoffee.com/trinity_21" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="40"></a>
## License
MIT
| text/markdown | TRINITY-21 | null | null | null | MIT | git, analytics, dashboard, tui, developer-tools, cli, coding-stats | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
... | [] | null | null | >=3.10 | [] | [] | [] | [
"textual>=0.40",
"textual-plotext>=0.2",
"plotext>=5.2",
"rich>=13.0",
"pytest>=7.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/TRINITY-21/huntd",
"Repository, https://github.com/TRINITY-21/huntd",
"Issues, https://github.com/TRINITY-21/huntd/issues"
] | twine/6.2.0 CPython/3.12.7 | 2026-02-18T10:31:57.607887 | huntd-0.6.1.tar.gz | 41,004 | 61/21/b0b85a450b3e546d1264f2c58c67d0a54a9d1c31b9dc63772527f0a6f3c0/huntd-0.6.1.tar.gz | source | sdist | null | false | b1b6f64960b90e4a7d1617053fbfea0f | beff7b1a618bfb68e222e01218c6b5e5fa69d32f26c32ea9a0e927a0b2649d17 | 6121b0b85a450b3e546d1264f2c58c67d0a54a9d1c31b9dc63772527f0a6f3c0 | null | [] | 258 |
2.1 | utg-base | 1.24.6 | UTG Base Package | # UTG Base | text/markdown | Olimboy | shavkatov.olimboy@mail.ru | null | null | null | null | [
"Programming Language :: Python :: 3"
] | [] | null | null | <4.0,>=3.14 | [] | [] | [] | [
"djangorestframework<4.0.0,>=3.16.1",
"djangorestframework-simplejwt[crypto]<6.0.0,>=5.5.1",
"django<6.0.0,>=5.2.7",
"django-filter<24.0,>=23.5",
"croniter<3.0.0,>=2.0.3",
"drf-spectacular[sidecar]<0.30.0,>=0.29.0",
"openpyxl<4.0.0,>=3.1.2",
"inflect<8.0.0,>=7.2.1",
"celery<6.0.0,>=5.5.3",
"django... | [] | [] | [] | [] | poetry/1.8.5 CPython/3.14.3 Linux/5.15.0-119-generic | 2026-02-18T10:31:45.566718 | utg_base-1.24.6.tar.gz | 23,050 | a2/b3/d9f93046d59d886081eae25c71d561c809b67a588160462d5a5d2ae68a52/utg_base-1.24.6.tar.gz | source | sdist | null | false | 13cbcf3bf4d807bcce3d98a43f4cdada | 485d3a0f7adfbec64b276d5dc7413336092050730943e253b0088a47aba157b6 | a2b3d9f93046d59d886081eae25c71d561c809b67a588160462d5a5d2ae68a52 | null | [] | 264 |
2.4 | agent-context-guard | 1.0.1 | Integrity verification and access control for AI agent context files | <div align="center">
<img width="456" height="400" alt="acg" src="https://github.com/user-attachments/assets/22dcee6a-7ae6-45c0-9134-72ac49251d84" />
[](https://python.org)
[](LICENSE)
[](https://github.com/kahalewai/agent-context-guard)
</div>
<br>
## Intro
Agent Context Guard is a runtime protection layer for AI agent markdown context files. Modern AI agents encode critical behavioral controls in plaintext markdown: persona definitions, tool instructions, rules, and skills. These files are implicitly trusted, mutable at runtime, and typically unprotected. Agent Context Guard seals these files with cryptographic signatures, detects tampering at runtime, and ensures that only humans can approve changes.
Agent Context Guard is intended to:
* Seal markdown files with cryptographic hashes and HMAC signatures
* Detect tampering, any modification to a protected file is caught immediately
* Provide a library-based guard API, agents call `guard.read()` for verified access
* Provide a proposal workflow, agents can propose changes but never approve them
* Preserve human ownership, edit protected files anytime through explicit sessions
* Recover from tampering, view diffs and choose to rollback or accept changes
* Log everything, append-only audit trail with automatic archival failsafe
* Integrate into CI/CD pipelines for continuous integrity verification
* Work with any agent framework via adapters or direct API
<br>
## Core Requirement
Agent Context Guard enforces a single core requirement across all operations:
<br>
> The agent never gains authority. The human never loses ownership. The guard never acts implicitly.
<br>
This means that:
* AI agents can read protected files but cannot modify them
* Humans remain the sole authority for approving changes
* Agents can propose changes with justifications
* All proposals require explicit human review and approval
* Every file operation is cryptographically sealed and logged
* Runtime protection is deterministic, no LLM-based decisions
* Audit records capture every access, denial, and modification
<br>
**Key Characteristics**
| Aspect | Scope |
| --------------------- | ------------------------------------------------- |
| Protection scope | Markdown files (.md, .markdown, .mdown, .mkd) |
| Signing algorithm | SHA-256 hash + HMAC-SHA256 signature |
| Policy enforcement | Deterministic, non-LLM-based |
| Agent integration | Framework agnostic (LangChain, CrewAI, OpenAI, Anthropic, AutoGen, LlamaIndex, MCP, OpenClaw) |
| Runtime overhead | Minimal, file-level verification only |
| Adoption model | Library API with CLI tooling |
<br>
## Quick Start
### Installation
```bash
# Install from PyPI
pip install agent-context-guard
# Verify installation
acg --version
```
### Basic Usage
```bash
# 1. Initialize in your project directory
acg init
# 2. Protect your agent's context files
acg protect prompts/*.md
# 3. Run your agent under the guard
acg run -- python my_agent.py
# 4. Verify integrity (CI/CD)
acg verify
```
### Python API
```python
from agent_context_guard import Guard
# Initialize with your project root
guard = Guard("/path/to/project")
# Read a protected file (with policy enforcement + audit)
content = guard.read("prompts/persona.md", agent_id="my-agent")
# Propose an update (requires human approval)
guard.propose(
"prompts/persona.md",
new_content="# Updated Persona\n...",
agent_id="my-agent",
justification="Updated greeting style",
)
# Check protection status
status = guard.status("prompts/persona.md")
# Scoped sessions for cleaner agent code
with guard.session(agent_id="my-agent") as s:
persona = s.read("prompts/persona.md")
rules = s.read("prompts/rules.md")
```
For complete setup instructions, see the [Implementation Guide](./IMPLEMENTATION_GUIDE.md).
<br>
## Package Structure
```
src/agent_context_guard/
├── __init__.py # Public API exports
├── guard.py # Central API (Guard, GuardSession)
├── core/
│ ├── audit.py # Append-only JSON Lines audit logger with archival
│ ├── constants.py # Paths, defaults, file extensions
│ ├── exceptions.py # Full exception hierarchy
│ ├── inventory.py # Atomic-write seal record registry
│ ├── policy.py # Deterministic policy engine
│ ├── proposals.py # Agent proposal workflow
│ ├── seal.py # SHA-256 hashing + HMAC-SHA256 signing
│ └── selfprotect.py # Guard metadata self-protection
├── cli/
│ ├── helpers.py # Rich terminal output helpers
│ └── main.py # All CLI commands (Click)
└── adapters/
├── anthropic_tools.py # Anthropic Claude tool-use adapter
├── autogen.py # AutoGen / AG2 adapter
├── crewai.py # CrewAI tool adapter
├── langchain.py # LangChain document loader adapter
├── llamaindex.py # LlamaIndex reader adapter
├── mcp.py # Model Context Protocol adapter
├── openclaw.py # OpenClaw skill adapter
└── openai_tools.py # OpenAI function-calling adapter
```
<br>
## CLI Commands
Agent Context Guard provides a complete CLI via the `acg` command:
| Command | Description |
|---------|-------------|
| `acg init` | Initialize guard in a directory |
| `acg protect <files>` | Register markdown files for protection |
| `acg run -- <cmd>` | Run a command under the runtime guard |
| `acg edit <file>` | Open a human edit session for a protected file |
| `acg status` | Show protection status (with silent integrity check) |
| `acg diff [file]` | Show pending proposal diffs |
| `acg approve <file>` | Approve a pending proposal and apply changes |
| `acg reject <file>` | Reject a pending proposal |
| `acg recover <file>` | Recover from file tampering (rollback or accept) |
| `acg audit` | Display the audit log |
| `acg verify` | CI/CD verification of sealed files and metadata |
| `acg rotate-keys` | Rotate the signing key and re-sign all files |
Use `acg <command> --help` for detailed options on any command.
<br>
## Works with Your Existing Agent Framework
Agent Context Guard was designed to work with any AI agent framework:
* No assumptions about agent framework or prompt format
* Python API available for direct integration (`guard.read()`)
* Pre-flight verification via `acg run -- <command>`
* Adapters included for LangChain, CrewAI, OpenAI, Anthropic, AutoGen, LlamaIndex, MCP, and OpenClaw
* Works with single-agent and multi-agent systems
* All operations are logged to an append-only audit trail
* Policy enforcement is deterministic, no LLM-based decisions
<br>
## Key Design Principles
* **Library-first architecture** agents call `guard.read()` for verified access
* **Framework agnostic** no assumptions about agent framework or prompt format
* **Deterministic control** all decisions are non-LLM-based
* **Agent autonomy without authority** agents propose, humans approve
* **Tamper recovery** detect changes and recover with `acg recover`
* **Audit failsafe** automatic log archival prevents unbounded growth
<br>
## Out of Scope
Agent Context Guard does not:
* Provide object-level authorization within files
* Act as a general-purpose file integrity monitor
* Replace authentication or identity management
* Perform prompt injection detection or content filtering
* Support encrypted file storage (sealing is for integrity, not confidentiality)
<br>
## Requirements
* Python 3.10+
* Dependencies (installed automatically): `click`, `cryptography`, `pyyaml`, `rich`
* No external services, databases, or daemons
<br>
## License
Apache License 2.0
<br>
<br>
| text/markdown | Agent Context Guard contributors | null | null | null | null | agent, ai, audit, context-guard, integrity, llm, markdown, seal, security, verification | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Langu... | [] | null | null | >=3.10 | [] | [] | [] | [
"click>=8.0",
"cryptography>=41.0",
"pyyaml>=6.0",
"rich>=13.0",
"crewai>=0.1; extra == \"all\"",
"langchain-core>=0.1; extra == \"all\"",
"llama-index-core>=0.10; extra == \"all\"",
"pyautogen>=0.2; extra == \"all\"",
"pyautogen>=0.2; extra == \"autogen\"",
"crewai>=0.1; extra == \"crewai\"",
"... | [] | [] | [] | [
"Homepage, https://github.com/kahalewai/agent-context-guard",
"Documentation, https://github.com/kahalewai/agent-context-guard#readme",
"Repository, https://github.com/kahalewai/agent-context-guard",
"Issues, https://github.com/kahalewai/agent-context-guard/issues"
] | twine/6.2.0 CPython/3.10.11 | 2026-02-18T10:30:04.124166 | agent_context_guard-1.0.1.tar.gz | 61,121 | dd/da/d5663d1670c7890f7cc13a0d7189614737ecda741448565536de49c134c1/agent_context_guard-1.0.1.tar.gz | source | sdist | null | false | 2547c88ac57af87bb92eb5746574b676 | f98d95e27d7bf4d5c3f3436ff92d851eff1a1d1565a198d6b372936fa5f1bdf5 | dddad5663d1670c7890f7cc13a0d7189614737ecda741448565536de49c134c1 | Apache-2.0 | [
"LICENSE"
] | 269 |
2.4 | mywork-ai | 3.0.0 | Complete AI-powered development framework with 78 CLI commands for code generation, project analysis, n8n workflow automation, security scanning, and deployment | # MyWork-AI
<div align="center">
**🤖 Build, Ship & Sell Software Products — From One CLI**
*72+ commands · AI code generation · Agent engine · Marketplace included · n8n automation*
[🚀 Quick Start](#-quick-start) · [🔧 Commands](#-command-reference) · [💡 Examples](#-examples) · [🛒 Marketplace](https://frontend-hazel-ten-17.vercel.app)
</div>
---
## What Is MyWork-AI?
MyWork-AI is a **complete development framework** that takes you from idea to shipped product to revenue. It combines project scaffolding, AI code generation, security scanning, n8n workflow automation, deployment tools, and a marketplace — all from a single `mw` command.
```
pip install mywork-ai → mw setup → mw new → build → mw deploy → mw marketplace publish
```
**This isn't another code assistant.** It's the full pipeline.
---
## 🚀 Quick Start
```bash
# Install
pip install mywork-ai
# Set up (configures API keys, preferences)
mw setup
# Create a project with AI (generates real code, not templates!)
mw new --ai "invoice API with PDF export and email delivery"
# Or use templates
mw new my-api fastapi
# Check health
cd my-project && mw doctor
# Run the AI agent built into your project
mw agent run agent.yaml
# Deploy
mw deploy
```
### ✨ AI Agent Engine (NEW in v2.7.0)
```bash
# Create an AI agent
mw agent init customer-bot
# Run it (CLI chat with tool calling)
mw agent run customer-bot.yaml
# Run with web UI
mw agent run customer-bot.yaml --web
# → Open http://localhost:8080
# Supports 100+ models: OpenAI, Claude, DeepSeek, Gemini, Ollama, Mistral...
```
Agent config is a simple YAML file:
```yaml
name: Code Reviewer
model: deepseek/deepseek-chat
instructions: |
Review code for bugs, security issues, and improvements.
tools:
- name: read_file
description: Read a source file
parameters:
path: {type: string, description: "File path"}
command: "cat '{path}'"
```
**You're live in 5 minutes.**
---
## ✨ Why MyWork-AI?
| Feature | MyWork-AI | Cursor | Aider | Zapier/Make |
|---------|-----------|--------|-------|-------------|
| CLI-first (any editor) | ✅ | ❌ | ✅ | ❌ |
| Project scaffolding | ✅ 12 templates | ❌ | ❌ | ❌ |
| AI code generation | ✅ | ✅ | ✅ | ❌ |
| Security scanning | ✅ | ❌ | ❌ | ❌ |
| n8n workflow automation | ✅ 16 commands | ❌ | ❌ | ✅ (paid) |
| Deployment pipeline | ✅ Multi-platform | ❌ | ❌ | ❌ |
| Cost tracking (AI APIs) | ✅ | ❌ | ❌ | ❌ |
| Secrets vault | ✅ Encrypted | ❌ | ❌ | ❌ |
| Product marketplace | ✅ Built-in | ❌ | ❌ | ✅ (paid) |
| Open source & free | ✅ | 💰 | 💰 | 💰 |
---
## 🔥 Core Features
### 🏗️ Project Scaffolding
```bash
mw new my-app basic # Simple Python project
mw new my-api fastapi # REST API with FastAPI
mw new my-saas saas # Full SaaS with auth, billing, dashboard
mw new my-bot chatbot # AI chatbot with conversation memory
mw new my-tool cli # Command-line tool with arg parsing
mw new my-scraper scraper # Web scraper with data export
mw new my-dash dashboard # Analytics dashboard
mw new my-auto automation # Task automation with scheduling
```
Each template includes: project structure, `.env.example`, tests, CI config, README, and `.planning/` directory with roadmap.
### 🤖 AI-Powered Development
```bash
mw ai generate # Create complete files from natural language
mw ai refactor # AST-based code improvements
mw ai review # Automated code review
mw prompt-enhance # Improve rough prompts for better AI output
mw context # Build smart context for AI assistants
```
### ⚡ n8n Workflow Automation (16 Commands)
```bash
mw n8n setup # One-command n8n install (Docker or npm)
mw n8n status # Check n8n health
mw n8n list # List all workflows
mw n8n import # Import workflow from JSON
mw n8n export # Export workflow
mw n8n activate # Activate/deactivate workflows
mw n8n exec # Execute a workflow
mw n8n test # Validate workflow before deploy
mw n8n templates # Browse 2,700+ community templates
mw n8n config # Manage n8n configuration
```
### 🛡️ Security & Quality
```bash
mw security # Full security scan (OWASP checks)
mw secrets set/get # Encrypted secrets vault (Fernet)
mw env audit # Environment variable security scan
mw deps # Dependency vulnerability check
mw health # Project health score (0-100)
mw doctor # Comprehensive diagnostics
mw selftest # Framework self-check (11 checks)
```
### 🚀 DevOps & Deployment
```bash
mw deploy # Multi-platform (Vercel, Railway, Docker)
mw ci # Auto-generate GitHub Actions CI/CD
mw launch # Pre-launch checklist with countdown
mw release # Version bump + changelog + publish
mw backup # Project backup & restore
```
### 💰 Cost & Analytics
```bash
mw cost estimate # Estimate AI API costs for your project
mw cost track # Running cost tracker across all providers
mw cost budget # Set monthly budget alerts
mw cost report # Monthly breakdown by model/provider
mw benchmark # Code performance profiling
mw stats # Project statistics dashboard
mw recap # Daily/weekly productivity summaries
```
### 🛒 Marketplace
```bash
mw marketplace browse # Browse products
mw marketplace search # Search by keyword
mw marketplace publish # Publish your project for sale
mw marketplace install # Download & install a product
mw clone <product> # Clone a marketplace product
```
---
## 🔧 Command Reference
<details>
<summary><strong>📋 All 67+ Commands</strong> (click to expand)</summary>
```bash
# Core
mw setup, mw init, mw new, mw status, mw doctor, mw health, mw selftest
# AI & Code Generation
mw ai generate, mw ai refactor, mw ai review, mw ai optimize
mw context, mw prompt-enhance
# Project Planning (GSD)
mw gsd new, mw gsd status, mw gsd progress
# Automation (n8n)
mw n8n setup, mw n8n status, mw n8n list, mw n8n import, mw n8n export
mw n8n activate, mw n8n exec, mw n8n test, mw n8n config, mw n8n templates
# AutoForge (Autonomous Coding)
mw af start, mw af status, mw af queue
# Marketplace
mw marketplace browse, mw marketplace publish, mw marketplace install
mw marketplace search, mw marketplace status, mw clone
# Analysis & Metrics
mw stats, mw benchmark, mw recap, mw todo, mw snapshot
# Security & Quality
mw security, mw secrets, mw deps, mw env, mw audit, mw lint
# DevOps & Deployment
mw deploy, mw ci, mw release, mw launch, mw backup, mw clean
# Cost Tracking
mw cost estimate, mw cost track, mw cost budget, mw cost report
# Git & Collaboration
mw git summary, mw changelog, mw share export, mw share import
# Knowledge Vault
mw brain search, mw brain add, mw brain stats
# Documentation & Onboarding
mw tour, mw demo, mw guide, mw quickstart, mw docs, mw links
# Utilities
mw version, mw upgrade, mw config, mw ecosystem, mw webhook test
mw templates, mw cron, mw monitor
```
</details>
---
## 💡 Examples
### Build a SaaS App
```bash
mw new invoicer saas
cd invoicer
mw doctor # Check project health
mw security # Security scan
mw deploy # Ship it
```
### Automate with n8n
```bash
mw n8n setup # Install n8n
mw n8n import lead-nurture.json # Import workflow
mw n8n test lead-nurture.json # Validate it
mw n8n activate 1 # Go live
```
### Sell on Marketplace
```bash
mw marketplace publish # Package & list your project
# Set price, description, tags
# Buyers get: mw clone <your-product>
```
### Track AI Costs
```bash
mw cost estimate # "Estimated $47/mo based on 15 API calls detected"
mw cost budget --set 50 # Alert when approaching $50/mo
mw cost report # Monthly breakdown: GPT-4 $23, Claude $18, Gemini $6
```
---
## 🏗️ Installation
### Requirements
- **Python**: 3.9+
- **OS**: Linux, macOS, Windows
- **Optional**: Git, Docker, Node.js (for n8n features)
### Install
```bash
# From PyPI (recommended)
pip install mywork-ai
# Development version
pip install git+https://github.com/dansidanutz/MyWork-AI.git
# Verify
mw version
mw selftest
```
---
## 📊 Stats
- **67+ CLI commands** across 12 categories
- **133 automated tests** passing
- **12 project templates** (basic → full SaaS)
- **16 n8n commands** for workflow automation
- **9 marketplace products** ready to sell
- **2,700+ n8n templates** browseable
- **v2.6.0** on PyPI
---
## 🤝 Contributing
```bash
git clone https://github.com/dansidanutz/MyWork-AI.git
cd MyWork-AI
pip install -e .[dev]
pytest # Run all 133 tests
```
See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
---
## 📄 License
MIT License — see [LICENSE](LICENSE).
---
<div align="center">
**⭐ Star us on GitHub if MyWork-AI helps you build faster!**
[⭐ Star on GitHub](https://github.com/DansiDanutz/MyWork-AI) · [🛒 Marketplace](https://frontend-hazel-ten-17.vercel.app) · [📦 PyPI](https://pypi.org/project/mywork-ai/)
*Built by [DansiDanutz](https://github.com/DansiDanutz)*
</div>
| text/markdown | Dan Sidanutz | Dan Sidanutz <dan@mywork.ai> | null | null | MIT | ai, artificial-intelligence, development, framework, automation, cli, developer-tools, code-generation, devops, project-management, security-scanning, code-analysis, deployment, testing, refactoring | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Pr... | [] | https://github.com/dansidanutz/MyWork-AI | null | >=3.9 | [] | [] | [] | [
"python-dotenv>=1.0.0",
"litellm>=1.40.0; extra == \"agent\"",
"pyyaml>=6.0; extra == \"agent\"",
"fastapi>=0.109.0; extra == \"api\"",
"uvicorn[standard]>=0.27.0; extra == \"api\"",
"pytest>=7.4.0; extra == \"dev\"",
"pytest-cov>=4.1.0; extra == \"dev\"",
"pytest-timeout>=2.2.0; extra == \"dev\"",
... | [] | [] | [] | [
"Homepage, https://github.com/dansidanutz/MyWork-AI",
"Documentation, https://docssite-igkwv43c5-irises-projects-ce549f63.vercel.app",
"Repository, https://github.com/dansidanutz/MyWork-AI",
"Issues, https://github.com/dansidanutz/MyWork-AI/issues",
"Changelog, https://github.com/dansidanutz/MyWork-AI/blob/... | twine/6.2.0 CPython/3.12.3 | 2026-02-18T10:29:55.965810 | mywork_ai-3.0.0.tar.gz | 2,999,645 | 6c/4d/85b37bf26978aa951cc5ba25e126736ac47c8dbf36c674c8911a5f22675d/mywork_ai-3.0.0.tar.gz | source | sdist | null | false | 12371fdb88439489c6c878b9bab2adf1 | 82cd9031606d4ab103ebb5d353b18a1cf44aa835c508358ed84d6b30fc024c8b | 6c4d85b37bf26978aa951cc5ba25e126736ac47c8dbf36c674c8911a5f22675d | null | [
"LICENSE"
] | 252 |
2.4 | unimport | 1.3.1 | The ultimate linter and formatter for removing unused import statements in your code. | 
**🚀 The ultimate linter and formatter for removing unused import statements in your
code.**
Looking for a way to eliminate those pesky unused import statements in your code? Look
no further than Unimport! This powerful tool serves as both a linter and formatter,
making it easy to detect and remove any imports that are no longer needed. Say goodbye
to cluttered, inefficient code and hello to a cleaner, more streamlined development
process with Unimport.
[](https://results.pre-commit.ci/latest/github/hakancelikdev/unimport/main)
[](https://pypi.org/project/unimport/)
[](https://pepy.tech/project/unimport)
[](https://github.com/hakancelikdev/unimport/blob/main/LICENSE)
[](https://github.com/hakancelikdev/unimport/fork)
[](https://github.com/hakancelikdev/unimport/issues)
[](https://github.com/hakancelikdev/unimport/stargazers)
[](https://codecov.io/gh/hakancelikdev/unimport)
[](https://github.com/hakancelikdev/unimport/graphs/contributors)
[](https://github.com/hakancelikdev/unimport/commits/main)
For more information see: https://unimport.hakancelik.dev/
Try it out now using the Unimport Playground,
https://playground-unimport.hakancelik.dev/
| text/markdown | null | Hakan Çelik <hakancelikdev@gmail.com> | null | null | MIT | unused, import | [
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.9",
"Programming L... | [] | null | null | <3.14,>=3.9 | [] | [] | [] | [
"libcst<=1.8.2,>=0.4.10; python_version >= \"3.11\"",
"libcst<=1.8.2,>=0.3.7; python_version == \"3.10\"",
"libcst<=1.8.2,>=0.3.7; python_version == \"3.9\"",
"pathspec<1,>=0.10.1",
"toml<1,>=0.9.0",
"mkdocs==1.6.1; extra == \"docs\"",
"mkdocs-material==9.6.16; extra == \"docs\"",
"mkdocs-markdownextr... | [] | [] | [] | [
"Documentation, https://unimport.hakancelik.dev/",
"Issues, https://github.com/hakancelikdev/unimport/issues/",
"Changelog, https://unimport.hakancelik.dev/1.3.1/CHANGELOG/"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:29:09.072430 | unimport-1.3.1.tar.gz | 25,889 | 14/1a/2d999777c7dff910716ab7164a4b12faadcc966f9a699fa434c6cad3bec9/unimport-1.3.1.tar.gz | source | sdist | null | false | 178f42749f2945916219437d8c1ad78a | 5b5fd8beae541966f116682f6addc6c34dec0e60630a27468a8ffefa52d20b50 | 141a2d999777c7dff910716ab7164a4b12faadcc966f9a699fa434c6cad3bec9 | null | [
"LICENSE"
] | 3,855 |
2.4 | medha-one-access | 0.3.12 | Enterprise access control system with BODMAS resolution and Redis caching | # MedhaOne Access Control 🔐
[](https://badge.fury.io/py/medha-one-access)
[](https://pypi.org/project/medha-one-access/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/medhaone-analytics/medha-one-access/actions)
A comprehensive, enterprise-grade access control system with BODMAS-based resolution for managing users, resources, and permissions with sophisticated expression-based rules.
## ✨ Features
### Core Access Control
- **BODMAS Resolution**: Predictable access resolution using mathematical precedence rules
- **Expression-Based Access**: Intuitive mathematical expressions for complex access patterns (`user1+group1-user2`)
- **Quoted Entity Support**: Handle entities with special characters using quotes (`"user-service-api"+"admin-panel"`)
- **Time-Based Constraints**: Schedule access with date ranges, time windows, and day-of-week restrictions
- **Hierarchical Organizations**: Support for manager-subordinate relationships and group hierarchies
### Architecture & Performance
- **Dual Architecture**: Both synchronous and asynchronous controllers for different use cases
- **Background Task Processing**: Non-blocking operations with automatic recalculation
- **Auto-Recalculation**: Intelligent background updates when users, groups, or rules change
- **⚡ Advanced Caching**: Multi-level caching system with 10x performance improvements
- **Connection Pooling**: Optimized database connections with configurable pool sizes
### Integration & APIs
- **FastAPI Integration**: Both sync and async web API mounting options
- **Comprehensive REST API**: 11 specialized router modules with 50+ endpoints
- **Data Import/Export**: JSON-based bulk operations and backup capabilities
- **CLI Tools**: Command-line interface for database management and operations
- **Database Agnostic**: PostgreSQL (recommended) and SQLite support
### Developer Experience
- **Type Safety**: Full TypeScript-style type hints and py.typed support
- **Comprehensive Audit**: Complete traceability of all access decisions (optional for performance)
- **Version Compatibility**: Works with any existing FastAPI, SQLAlchemy, Pydantic versions
- **Zero Conflicts**: Never upgrades/downgrades your existing packages
## 🚀 Quick Start
### Installation
#### From Git Repository (Internal/Private Use)
```bash
# Basic installation from Git
pip install git+https://github.com/Medhahealth-AI/medha-one-access.git
# Install specific version
pip install git+https://github.com/Medhahealth-AI/medha-one-access.git@v1.0.0
# With FastAPI support
pip install "git+https://github.com/Medhahealth-AI/medha-one-access.git[api]"
# With CLI tools
pip install "git+https://github.com/Medhahealth-AI/medha-one-access.git[cli]"
# Full installation with all features
pip install "git+https://github.com/Medhahealth-AI/medha-one-access.git[all]"
# For requirements.txt (pin to specific version)
git+https://github.com/Medhahealth-AI/medha-one-access.git@v1.0.0#egg=medha-one-access[api]
```
#### From PyPI (Public Release)
```bash
# Basic installation
pip install medha-one-access
# With FastAPI support
pip install medha-one-access[api]
# With CLI tools
pip install medha-one-access[cli]
# Full installation with all features
pip install medha-one-access[all]
```
### Zero Version Conflicts Approach
This library is designed to work with **any versions** of dependencies already installed in your environment. It won't force upgrades or downgrades of your existing packages.
**Key Features:**
- ✅ **Version Agnostic**: No minimum/maximum version requirements
- ✅ **Compatibility Layer**: Automatically adapts to your environment
- ✅ **Graceful Degradation**: Features fail gracefully if dependencies missing
- ✅ **No Conflicts**: Won't alter your existing package versions
**Installation:**
```bash
# Works with any existing FastAPI, Pydantic, SQLAlchemy versions
pip install git+https://github.com/Medhahealth-AI/medha-one-access.git
# Only installs missing core dependencies (without version constraints)
# Never upgrades/downgrades existing packages
```
**How it Works:**
```python
from medha_one_access import AccessController
# Core functionality always works
controller = AccessController("postgresql://...")
# Optional features check availability automatically
try:
from medha_one_access.api import create_app # Only if FastAPI available
app = create_app() # Uses whatever FastAPI version you have
except ImportError:
print("FastAPI not available - API features disabled")
# CLI features work the same way
try:
from medha_one_access.cli import app # Only if CLI deps available
except ImportError:
print("CLI dependencies not available")
```
**Compatibility Promise:**
- Works with Python 3.8+
- Works with any Pydantic version (1.x or 2.x)
- Works with any SQLAlchemy version (1.4+ or 2.x)
- Works with any FastAPI version (if available)
- Never causes version conflicts with your existing environment
### Basic Usage
#### Synchronous Controller (Recommended for most use cases)
```python
from medha_one_access import AccessController
# Initialize the sync controller (includes background task processing)
controller = AccessController(database_url="postgresql://user:pass@localhost/db")
# Create users
controller.create_user("alice", type="USER", email="alice@company.com")
controller.create_user("developers", type="USERGROUP", expression="alice+bob+charlie")
# Create resources
controller.create_artifact("app-server", type="RESOURCE", description="Application Server")
controller.create_artifact("dev-resources", type="RESOURCEGROUP", expression="app-server+database+cache")
# Create access rules
controller.create_access_rule(
rule_id="dev-access",
user_expression="developers",
resource_expression="dev-resources",
permissions=["READ", "WRITE", "DEPLOY"]
)
# Check access
has_access = controller.check_access("alice", "app-server", "READ")
print(f"Alice can read app-server: {has_access}")
# Get all access for a user (fast - no audit trail)
user_access = controller.resolve_user_access("alice")
print(f"Alice has access to: {list(user_access['resolved_access'].keys())}")
# Get access with detailed audit trail (slower but comprehensive)
user_access_with_audit = controller.resolve_user_access("alice", include_audit=True)
print(f"Audit trail steps: {len(user_access_with_audit['audit_trail'])}")
# Background processing - operations return immediately!
controller.update_user("developers", {"expression": "alice+bob+charlie+new_dev"})
# ↑ Returns immediately, recalculation happens in background
# Optional cleanup (recommended for long-running applications)
controller.close()
```
#### Asynchronous Controller (For high-performance async applications)
```python
from medha_one_access import AsyncAccessController
# Initialize the async controller
async def main():
controller = AsyncAccessController(database_url="postgresql://user:pass@localhost/db")
await controller.initialize() # Required for async controller
# All operations are async and return immediately
await controller.create_user({"id": "alice", "type": "USER"})
await controller.create_user({"id": "developers", "type": "USERGROUP", "expression": "alice+bob"})
# Check access (async)
has_access = await controller.check_access("alice", "app-server", "READ")
print(f"Alice can read app-server: {has_access}")
# Get user access with advanced background task management
user_access = await controller.get_user_access("alice", max_cache_age_minutes=60)
print(f"Alice has access to: {list(user_access['resolved_access'].keys())}")
# Monitor background tasks
task_status = await controller.get_background_task_status()
print(f"Background tasks: {task_status}")
# Cleanup
await controller.close()
# Run async code
import asyncio
asyncio.run(main())
```
## 📚 Complete CRUD Operations
### User Management
The library provides complete CRUD (Create, Read, Update, Delete) operations for users and user groups:
```python
from medha_one_access import AccessController, LibraryConfig
# Initialize with application filtering and performance optimization
config = LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
application_name="MyApp", # Optional: filters all operations by application
# 🚀 Performance optimization settings
enable_caching=True, # Enable advanced caching (default: True)
cache_ttl=300, # Cache TTL in seconds (default: 5 minutes)
enable_bulk_queries=True, # Enable bulk operations (default: True)
enable_audit_trail=False, # Disable audit for speed (default: False)
max_pool_size=20, # Database connection pool size (default: 20)
pool_recycle_time=3600, # Pool recycle time in seconds (default: 1 hour)
)
controller = AccessController(config)
# CREATE USER
user = controller.create_user({
"id": "john.doe",
"type": "USER",
"email": "john.doe@company.com",
"first_name": "John",
"last_name": "Doe",
"department": "Engineering",
"role": "Senior Developer",
"active": True
})
# CREATE USER GROUP
group = controller.create_user({
"id": "senior_developers",
"type": "USERGROUP",
"name": "Senior Developers",
"expression": "john.doe+jane.smith+alice.wilson",
"description": "Senior development team members",
"active": True
})
# GET USER
user = controller.get_user("john.doe")
print(f"Found user: {user.first_name} {user.last_name}")
# UPDATE USER
updated_user = controller.update_user("john.doe", {
"role": "Lead Developer",
"department": "Platform Engineering"
})
# DELETE USER
success = controller.delete_user("john.doe")
print(f"User deleted: {success}")
# LIST USERS
all_users = controller.list_users() # All users
users_only = controller.list_users(user_type="USER") # Individual users only
groups_only = controller.list_users(user_type="USERGROUP") # User groups only
# Pagination
paginated_users = controller.list_users(skip=0, limit=50)
```
### Artifact Management
Complete CRUD operations for resources and resource groups:
```python
# CREATE ARTIFACT/RESOURCE
artifact = controller.create_artifact({
"id": "sales_dashboard",
"type": "RESOURCE",
"name": "Sales Analytics Dashboard",
"description": "Real-time sales performance dashboard",
"application": "Analytics", # Optional - auto-set if application_name configured
"active": True
})
# CREATE ARTIFACT GROUP
resource_group = controller.create_artifact({
"id": "analytics_suite",
"type": "RESOURCEGROUP",
"name": "Analytics Suite",
"expression": "sales_dashboard+marketing_dashboard+financial_reports",
"description": "Complete analytics platform",
"active": True
})
# GET ARTIFACT
artifact = controller.get_artifact("sales_dashboard")
print(f"Found resource: {artifact.name}")
# UPDATE ARTIFACT
updated_artifact = controller.update_artifact("sales_dashboard", {
"name": "Enhanced Sales Dashboard",
"description": "Advanced sales analytics with ML insights",
"active": True
})
# DELETE ARTIFACT
success = controller.delete_artifact("sales_dashboard")
print(f"Artifact deleted: {success}")
# LIST ARTIFACTS
all_artifacts = controller.list_artifacts() # All artifacts
resources_only = controller.list_artifacts(artifact_type="RESOURCE") # Individual resources
groups_only = controller.list_artifacts(artifact_type="RESOURCEGROUP") # Resource groups
app_artifacts = controller.list_artifacts(application="Analytics") # By application
active_only = controller.list_artifacts(active=True) # Active only
# Pagination
paginated_artifacts = controller.list_artifacts(skip=0, limit=100)
```
### Access Rules Management
Complete CRUD for access control rules:
```python
# CREATE ACCESS RULE
rule = controller.create_access_rule({
"id": "analytics_access",
"name": "Analytics Team Access",
"user_expression": "data_analysts+senior_developers",
"resource_expression": "analytics_suite-sensitive_financial_data",
"permissions": ["READ", "WRITE", "EXPORT"],
"application": "Analytics",
"active": True,
"time_constraints": {
"startTime": "08:00",
"endTime": "18:00",
"daysOfWeek": [1, 2, 3, 4, 5], # Monday-Friday
"startDate": "2024-01-01",
"endDate": "2024-12-31"
}
})
# GET ACCESS RULE
rule = controller.get_access_rule("analytics_access")
# UPDATE ACCESS RULE
updated_rule = controller.update_access_rule("analytics_access", {
"permissions": ["READ", "WRITE", "EXPORT", "ADMIN"],
"user_expression": "data_analysts+senior_developers+team_leads"
})
# DELETE ACCESS RULE
success = controller.delete_access_rule("analytics_access")
# LIST ACCESS RULES
all_rules = controller.list_access_rules()
filtered_rules = controller.list_access_rules(
user_expression="developers",
resource_expression="dashboards",
application="Analytics",
active=True,
skip=0,
limit=50
)
```
### Application Filtering
When `application_name` is configured, all operations are automatically filtered:
```python
# Configure with application filtering
config = LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
application_name="CRM" # All operations filter by this application
)
controller = AccessController(config)
# Create operations automatically set application field
artifact = controller.create_artifact({
"id": "customer_dashboard",
"type": "RESOURCE",
"name": "Customer Dashboard"
# application="CRM" is automatically set
})
# List operations only return CRM application data
crm_artifacts = controller.list_artifacts() # Only CRM artifacts
crm_rules = controller.list_access_rules() # Only CRM access rules
# Environment variable support
# Set MEDHA_APPLICATION_NAME=CRM
config = LibraryConfig.from_env()
controller = AccessController(config) # Auto-filters by CRM
```
### Batch Operations
Efficient bulk operations for large datasets:
```python
# Batch create users
users_data = [
{"id": f"user{i}", "type": "USER", "email": f"user{i}@company.com"}
for i in range(100)
]
created_users = []
for user_data in users_data:
try:
user = controller.create_user(user_data)
created_users.append(user)
except Exception as e:
print(f"Failed to create {user_data['id']}: {e}")
# Upsert operation (create or update)
user = controller.create_user({
"id": "existing_user",
"type": "USER",
"email": "updated@company.com"
}, upsert=True) # Updates if exists, creates if not
```
## 🏗️ Architecture
### BODMAS Resolution Priority
The system resolves access using mathematical precedence rules:
1. **UserGroup × ResourceGroup** (Highest Priority)
2. **UserGroup × Individual Resource**
3. **Individual User × ResourceGroup**
4. **Individual User × Individual Resource** (Lowest Priority)
This ensures predictable and intuitive access resolution where group-level permissions take precedence over individual assignments.
### Expression System
Use mathematical-style expressions for flexible access definitions:
#### Basic Expressions
```python
# Include specific users/resources
"alice+bob+charlie"
# Include groups and exclude individuals
"developers+admins-intern_user"
# Complex nested expressions
"senior_devs+(junior_devs-trainee)+alice"
```
#### Quoted Entity Support (v0.2.0+)
Handle entities with special characters using quotes:
```python
# Entities with hyphens, spaces, and special characters
'"user-service-api"+"admin-panel"+"database-server"'
# Mixed quoted and unquoted entities
'alice+"user-with-hyphens"+bob+"Service: Analytics"'
# Entities with colons, commas, apostrophes
'"Entity: Test"+"Entity, Demo"+"FD\'s Snapshot"'
# Complex expressions with quoted entities
'"analytics-team"+(developers-"intern-users")+"team-leads"'
```
#### Expression Validation
The system automatically validates expressions and provides helpful error messages:
```python
# Validate expressions
result = controller.validate_expression('"user-api"+"admin-panel"', "user")
if result["valid"]:
print(f"Expression resolves to: {result['resolved_entities']}")
else:
print(f"Validation error: {result['error']}")
```
### Time Constraints
Schedule access with sophisticated time-based rules:
```python
controller.create_access_rule(
rule_id="business-hours-only",
user_expression="employees",
resource_expression="production-systems",
permissions=["READ"],
time_constraints={
"startTime": "09:00",
"endTime": "17:00",
"daysOfWeek": [1, 2, 3, 4, 5], # Monday-Friday
"startDate": "2024-01-01",
"endDate": "2024-12-31"
}
)
```
## 🔄 Background Processing & Auto-Recalculation
### Automatic Background Recalculation
The library automatically recalculates affected user access when data changes, ensuring consistency while maintaining performance:
#### Sync Controller Background Processing
```python
from medha_one_access import AccessController, LibraryConfig
# Configure background processing
config = LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
# Background processing settings
enable_auto_recalculation=True, # Enable auto-recalculation (default: True)
auto_recalc_mode="immediate", # "immediate" or "batched"
auto_recalc_batch_size=50, # Batch size for batched mode
background_threads=3 # Thread pool size for background tasks
)
controller = AccessController(config)
# Operations return immediately, recalculation happens in background
controller.update_user("developers", {"expression": "alice+bob+new_dev"})
# ↑ Returns immediately, affected users recalculated in background
# Monitor background tasks
task_count = controller.get_background_task_count()
task_status = controller.get_background_task_status()
print(f"Active background tasks: {task_count}")
print(f"Task details: {task_status}")
# Cleanup when done
controller.close() # Shuts down background thread pool
```
#### Async Controller Advanced Task Management
```python
from medha_one_access import AsyncAccessController, LibraryConfig
async def main():
# Configure advanced background processing
config = LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
# Advanced async settings
background_workers=5, # Number of background workers
max_queue_size=10000, # Task queue size
enable_auto_recalculation=True
)
controller = AsyncAccessController(config)
await controller.initialize()
# All operations trigger intelligent background recalculation
await controller.update_user("team_leads", {"expression": "alice+bob+charlie"})
# Advanced task monitoring
queue_stats = await controller.get_background_queue_stats()
task_status = await controller.get_background_task_status("task_id")
print(f"Queue stats: {queue_stats}")
print(f"Task status: {task_status}")
# Wait for specific tasks to complete (useful for testing)
await controller.wait_for_background_tasks(timeout=30)
await controller.close()
```
### Configuration Options
Control how background recalculation works:
```python
config = LibraryConfig(
# Auto-recalculation settings
enable_auto_recalculation=True, # Enable/disable auto-recalculation
auto_recalc_mode="immediate", # "immediate", "batched", or "disabled"
auto_recalc_batch_size=50, # Users per batch in batched mode
# Background processing (sync controller)
background_threads=3, # Thread pool size
# Background processing (async controller)
background_workers=5, # Worker count
max_queue_size=10000, # Queue capacity
)
```
### When Auto-Recalculation Triggers
Background recalculation automatically triggers when:
- **User Group Expressions Change**: Adding/removing users from groups
- **User Deletions**: When user groups lose members
- **Access Rule Changes**: When permissions are modified
- **Artifact Changes**: When resource groups are updated
- **Resource Deletions**: When resources are removed from groups
## ⚡ Performance Configuration
The library includes advanced performance optimizations for high-load production environments:
### Performance Settings
```python
from medha_one_access import AccessController, LibraryConfig
# High-performance configuration for production
config = LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
# 🚀 Performance optimization settings
enable_caching=True, # LRU caching for expressions and queries
cache_ttl=300, # Cache for 5 minutes (adjust based on data freshness needs)
enable_bulk_queries=True, # Use bulk operations to reduce N+1 problems
enable_audit_trail=False, # Disable for 2-3x faster resolution
max_pool_size=50, # Increase for high concurrency (default: 20)
pool_recycle_time=1800, # Recycle connections every 30 minutes
)
controller = AccessController(config)
```
### Environment Variables
Configure performance settings via environment variables:
```bash
# Core settings
export MEDHA_DATABASE_URL="postgresql://user:pass@localhost/db"
export MEDHA_SECRET_KEY="your-secret-key"
export MEDHA_APPLICATION_NAME="MyApp"
# 🚀 Performance settings
export MEDHA_ENABLE_CACHING=true # Enable caching (default: true)
export MEDHA_CACHE_TTL=300 # Cache TTL in seconds (default: 300)
export MEDHA_ENABLE_BULK_QUERIES=true # Enable bulk operations (default: true)
export MEDHA_ENABLE_AUDIT_TRAIL=false # Disable audit for speed (default: false)
export MEDHA_MAX_POOL_SIZE=50 # Connection pool size (default: 20)
export MEDHA_POOL_RECYCLE_TIME=1800 # Pool recycle seconds (default: 3600)
# Cache expiration settings
export MEDHA_ENABLE_TIME_BASED_CACHE_EXPIRATION=false # Disable time-based cache expiration (default: true)
export MEDHA_DEFAULT_CACHE_AGE_MINUTES=60 # Default cache age if time-based enabled (default: 60)
# Load configuration from environment
config = LibraryConfig.from_env()
controller = AccessController(config)
```
### Cache Expiration Strategy
The library supports two cache invalidation strategies that can be used together or independently:
#### 1. Event-Based Invalidation (Always Active)
Automatically invalidates cache when data changes:
- User/UserGroup create/update/delete
- Artifact/ResourceGroup create/update/delete
- AccessRule create/update/delete
When data changes, the library:
1. Marks affected cache entries as stale (`is_stale = True`)
2. Triggers background recalculation to refresh the cache
#### 2. Time-Based Expiration (Configurable)
Invalidates cache based on age, regardless of data changes.
**When to Use Time-Based Expiration:**
- ✅ System has time-constrained access rules (`time_constraints` in rules)
- ✅ Database can be modified directly (outside the API)
- ✅ Different consumers need different freshness guarantees
- ✅ Extra safety net for missed invalidations
**When to Disable Time-Based Expiration:**
- ✅ No time-constrained access rules in your system
- ✅ Robust background recalculation with retries
- ✅ All database changes go through the API
- ✅ All consumers have same freshness requirements
**Configuration Examples:**
```python
# Option 1: Enable time-based expiration (default, current behavior)
config = LibraryConfig(
database_url="postgresql://...",
secret_key="...",
enable_time_based_cache_expiration=True, # Check cache age
default_cache_age_minutes=60, # Expire after 60 minutes
)
# Option 2: Disable time-based expiration (pure event-based)
config = LibraryConfig(
database_url="postgresql://...",
secret_key="...",
enable_time_based_cache_expiration=False, # Only use is_stale flag
enable_auto_recalculation=True, # Keep background recalc
auto_recalc_mode="batched", # Use batched mode
)
```
**Environment Variables:**
```bash
# Disable time-based expiration (rely on event-based only)
export MEDHA_ENABLE_TIME_BASED_CACHE_EXPIRATION=false # Default: true
export MEDHA_DEFAULT_CACHE_AGE_MINUTES=60 # Default: 60
```
**Performance Impact:**
- When disabled: ~5-10% faster cache reads (no timestamp calculations)
- When disabled: Higher cache hit rates (fewer time-based invalidations)
### Performance Features
#### 1. **Multi-Level Caching**
- **Expression Parsing Cache**: 1000 parsed expressions cached
- **Expression Validation Cache**: 500 validation results cached
- **Session-Level Caching**: Eliminates repeated queries within operations
- **Global Performance Cache**: 10,000 items with configurable TTL
#### 2. **Database Optimizations**
- **Strategic Indexes**: Added on all critical query columns
- **Connection Pooling**: Optimized pool sizes and recycling
- **Bulk Operations**: New methods to reduce N+1 query problems
- **Query Pre-filtering**: Only processes relevant rules per application/user
#### 3. **Algorithm Optimizations**
- **Smart Rule Filtering**: Pre-filters rules before BODMAS processing
- **Optional Audit Trail**: Disabled by default for 2-3x speed improvement
- **Memoized Resolutions**: Caches resolved expressions across operations
### Performance Benchmarks
| Operation | Before | After | Improvement |
|-----------|--------|-------|-------------|
| **Simple access check** | ~5ms | ~0.5ms | **10x faster** |
| **Complex group resolution** | ~500ms | ~50ms | **10x faster** |
| **High-load scenarios** | 100 req/s | 1000+ req/s | **10x throughput** |
| **Database queries** | 100+ per operation | 5-10 per operation | **90% reduction** |
### Usage Recommendations
#### High-Performance Mode (Production)
```python
config = LibraryConfig(
database_url="postgresql://...",
secret_key="...",
enable_caching=True, # Enable all caching
enable_audit_trail=False, # Disable for maximum speed
max_pool_size=50, # Scale for high load
)
# Fast access resolution (no audit)
access = controller.resolve_user_access("user@example.com")
```
#### Development Mode (Full Audit)
```python
config = LibraryConfig(
database_url="postgresql://...",
secret_key="...",
enable_audit_trail=True, # Enable for debugging
cache_ttl=30, # Short cache for testing
)
# Full audit trail for development
access = controller.resolve_user_access("user@example.com", include_audit=True)
print(access['audit_trail']) # See detailed resolution steps
```
## 🌐 Comprehensive REST API
### Available Endpoints
The library provides 50+ REST API endpoints organized into 11 specialized routers:
#### User Management (`/users`)
```http
POST /users # Create user/user group
GET /users/{user_id} # Get user details
PUT /users/{user_id} # Update user
DELETE /users/{user_id} # Delete user
GET /users # List users with filtering
GET /users/{user_id}/groups # Get user's groups
```
#### Artifact Management (`/artifacts`)
```http
POST /artifacts # Create artifact/resource group
GET /artifacts/{artifact_id} # Get artifact details
PUT /artifacts/{artifact_id} # Update artifact
DELETE /artifacts/{artifact_id} # Delete artifact
GET /artifacts # List artifacts with filtering
GET /artifacts/{artifact_id}/groups # Get artifact's groups
```
#### Access Rules (`/access-rules`)
```http
POST /access-rules # Create access rule
GET /access-rules/{rule_id} # Get access rule details
PUT /access-rules/{rule_id} # Update access rule
DELETE /access-rules/{rule_id} # Delete access rule
GET /access-rules # List access rules with filtering
POST /access-rules/validate-expression # Validate expressions
```
#### Access Resolution (`/access`)
```http
POST /access/resolve/{user_id} # Resolve all user access (BODMAS)
POST /access/check # Check specific access
GET /access/user/{user_id} # Get user access (alias)
GET /access/user/{user_id}/cached # Get cached user access (fast)
GET /access/resource/{resource_id} # Get resource access
GET /access/usergroup/{group_id} # Get user group access
GET /access/resourcegroup/{group_id} # Get resource group access
```
#### User Groups (`/usergroups`)
```http
GET /usergroups/{group_id} # Get user group details
GET /usergroups/{group_id}/members # Get group members
```
#### Resource Groups (`/resourcegroups`)
```http
GET /resourcegroups/{group_id} # Get resource group details
GET /resourcegroups/{group_id}/contents # Get group contents
```
#### Access Summaries (`/summaries`)
```http
GET /summaries/{user_id} # Get access summary
POST /summaries/calculate/{user_id} # Calculate access summary
GET /summaries/stats/overview # Get overview statistics
```
#### Data Import/Export (`/data`)
```http
POST /data/import # Import data from JSON
GET /data/export # Export data to JSON
POST /data/validate # Validate data integrity
GET /data/health # Health check
```
#### Expression Tools (`/expressions`)
```http
POST /expressions/validate # Validate expressions
```
#### Reporting (`/reporting`)
```http
GET /reporting/access-matrix # Access control matrix
GET /reporting/user-permissions/{user_id} # User permission report
```
### API Examples
```python
import requests
base_url = "http://localhost:8000/api/access"
# Create a user group
response = requests.post(f"{base_url}/users", json={
"id": "developers",
"type": "USERGROUP",
"expression": '"alice"+"bob"+"charlie"',
"description": "Development team"
})
# Check access
response = requests.post(f"{base_url}/access/check", json={
"user_id": "alice",
"resource_id": "api-server",
"permission": "READ"
})
print(f"Has access: {response.json()['access_granted']}")
# Get user access with caching
response = requests.get(f"{base_url}/access/user/alice/cached?max_cache_age_minutes=30")
user_access = response.json()
print(f"Alice can access: {list(user_access['resolved_access'].keys())}")
# Import bulk data
with open("access_data.json", "r") as f:
data = json.load(f)
response = requests.post(f"{base_url}/data/import", json=data)
print(f"Import status: {response.json()}")
```
## 🔧 Advanced Usage
### Database Setup
```bash
# Initialize database
medha-access init-db --database-url postgresql://user:pass@localhost/db
# Run migrations
medha-access migrate
# Check database status
medha-access status
```
### FastAPI Integration
#### Synchronous Integration (Recommended)
```python
from fastapi import FastAPI
from medha_one_access import LibraryConfig, mount_access_control_routes
app = FastAPI(title="My API with Access Control")
# Mount access control routes (sync version)
controller = mount_access_control_routes(
app=app,
config=LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
api_prefix="/api/access",
application_name="MyApp" # Optional: filters all operations
)
)
# Your API now has 50+ endpoints like:
# POST /api/access/users - Create user
# GET /api/access/users/{user_id}/access - Get user access
# POST /api/access/check - Check access
# GET /api/access/health - Health check
# POST /api/access/data/import - Import data
# GET /api/access/reporting/access-matrix - Access reports
```
#### Asynchronous Integration (High-Performance)
```python
from fastapi import FastAPI
from medha_one_access import LibraryConfig, mount_async_access_control_routes
app = FastAPI(title="High-Performance API with Access Control")
@app.on_event("startup")
async def startup():
# Mount async access control routes
global async_controller
async_controller = await mount_async_access_control_routes(
app=app,
config=LibraryConfig(
database_url="postgresql://user:pass@localhost/db",
secret_key="your-secret-key",
api_prefix="/api/access",
application_name="MyApp",
# Performance settings
background_workers=5, # Background task workers
max_pool_size=20, # DB connection pool
enable_caching=True # Advanced caching
)
)
@app.on_event("shutdown")
async def shutdown():
await async_controller.close()
# Async version provides the same 50+ endpoints with:
# - Non-blocking background recalculation
# - Advanced task queue management
# - Real-time task monitoring
# - Higher throughput and concurrency
```
### Django Integration
```python
from django.conf import settings
from medha_one_access import AccessController
# In your Django app
controller = AccessController(database_url=settings.DATABASES['access_control'])
def check_user_permission(request, resource_id, permission):
return controller.check_access(
user_id=request.user.username,
resource_id=resource_id,
permission=permission
)
```
### Docker Integration
When using in Docker containers with internal Git repositories:
```dockerfile
FROM python:3.11-slim
# Install git (required for git+https installs)
RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
# Copy requirements
COPY requirements.txt .
# Install dependencies (including internal library)
RUN pip install -r requirements.txt
# Rest of your application
COPY . /app
WORKDIR /app
CMD ["python", "app.py"]
```
**requirements.txt:**
```txt
# Internal access control library
git+https://github.com/Medhahealth-AI/medha-one-access.git@v1.0.0#egg=medha-one-access[api]
# Other dependencies
fastapi>=0.95.0
uvicorn>=0.21.1
```
**Docker Compose Example:**
```yaml
version: '3.8'
services:
app:
build: .
environment:
- MEDHA_DATABASE_URL=postgresql://user:pass@db:5432/access_db
- MEDHA_SECRET_KEY=your-secret-key
depends_on:
- db
db:
image: postgres:15
environment:
POSTGRES_DB: access_db
POSTGRES_USER: user
POSTGRES_PASSWORD: pass
```
### Batch Operations
```python
# Bulk user creation
users = [
{"id": "alice", "type": "USER", "department": "Engineering"},
{"id": "bob", "type": "USER", "department": "Engineering"},
{"id": "charlie", "type": "USER", "department": "Marketing"},
]
for user_data in users:
controller.create_user(**user_data)
# Import from JSON
controller.import_data_from_file("access_data.json")
# Export current state
controller.export_data_to_file("backup.json")
```
## 📚 Documentation
### Core Concepts
- **Users**: Individual users or user groups with expression-based membership
- **Artifacts**: Resources or resource groups with expression-based contents
- **Access Rules**: Define permissions between user expressions and resource expressions
- **Time Constraints**: Optional time-based restrictions on access rules
- **Access Summaries**: Pre-calculated access data for performance optimization
### API Reference
Full API documentation is available at: [https://medha-one-access.readthedocs.io/](https://medha-one-access.readthedocs.io/)
### Examples
Check the [examples/](examples/) directory for:
- Basic usage patterns
- FastAPI integration
- Django integration
- Complex expression examples
- Time constraint scenarios
- Migration from standalone application
## 🧪 Development
### Setup Development Environment
```bash
git clone https://github.com/Medhahealth-AI/medha-one-access.git
cd medha-one-access
pip install -e .[dev]
# Format and lint code
black medha_one_access/
flake8 medha_one_access/
mypy medha_one_access/
```
### Code Quality
```bash
# Format code
black medha_one_access/
# Lint code
flake8 medha_one_access/
# Type checking
mypy medha_one_access/
```
## 📈 Changelog
See [CHANGELOG.md](CHANGELOG.md) for a detailed history of changes.
| text/markdown | MedhaOne Analytics | MedhaOne Analytics <contactmedhaanalytics@gmail.com> | null | MedhaOne Analytics <contactmedhaanalytics@gmail.com> | MIT | access-control, authorization, permissions, rbac, abac, bodmas, expressions, security, fastapi, sqlalchemy | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python ... | [] | https://github.com/medhaone-analytics/medha-one-access | null | >=3.8 | [] | [] | [] | [
"sqlalchemy[asyncio]>=2.0.0",
"pydantic",
"asyncpg>=0.28.0",
"aiosqlite>=0.19.0",
"cryptography",
"alembic",
"python-dateutil",
"aiofiles>=23.0.0",
"asyncio-throttle>=1.0.2",
"redis[hiredis]>=5.0.0",
"fastapi; extra == \"api\"",
"uvicorn; extra == \"api\"",
"python-multipart; extra == \"api\... | [] | [] | [] | [
"Homepage, https://github.com/medhaone-analytics/medha-one-access",
"Documentation, https://medha-one-access.readthedocs.io/",
"Repository, https://github.com/medhaone-analytics/medha-one-access",
"Bug Reports, https://github.com/medhaone-analytics/medha-one-access/issues",
"Changelog, https://github.com/me... | twine/6.2.0 CPython/3.11.4 | 2026-02-18T10:29:06.377846 | medha_one_access-0.3.12.tar.gz | 151,404 | 07/6e/123bda3047f3215b4a6bc95cf51ce6d762613783d4a9d51d79a43421f928/medha_one_access-0.3.12.tar.gz | source | sdist | null | false | 6852369c759a76adfe927bb4ff82f001 | fbf06cdb09716a8fbdad135b1b58580f27512e0236a8cb3aa614e9d6c68313e3 | 076e123bda3047f3215b4a6bc95cf51ce6d762613783d4a9d51d79a43421f928 | null | [
"LICENSE"
] | 260 |
2.4 | supervisely | 6.73.532 | Supervisely Python SDK. | <h1 align="center">
<a href="https://supervisely.com"><img alt="Supervisely" title="Supervisely" src="https://i.imgur.com/B276eMS.png"></a>
</h1>
<h3 align="center">
<a href="https://supervisely.com">Computer Vision Platform</a>,
<a href="https://ecosystem.supervisely.com/">Open Ecosystem of Apps</a>,
<a href="https://developer.supervisely.com/">SDK for Python</a>
</h3>
<p align="center">
<a href="https://pypi.org/project/supervisely" target="_blank">
<img src="https://static.pepy.tech/personalized-badge/supervisely?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pip%20installs" alt="Package version">
</a>
<a href="https://hub.docker.com/r/supervisely/agent/tags" target="_blank">
<img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/supervisely/agent?label=docker%20pulls%20-%20supervisely%2Fagent">
</a>
<br/>
<a href="https://pypi.org/project/supervisely" target="_blank">
<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/supervisely?color=4ec528">
</a>
<a href="https://supervisely.com/slack" target="_blank"> <img src="https://img.shields.io/badge/slack-chat-green.svg?logo=slack&color=4ec528" alt="Slack">
</a>
<a href="https://pypi.org/project/supervisely" target="_blank">
<img src="https://img.shields.io/pypi/v/supervisely?color=4ec528&label=pypi%20package" alt="Package version">
</a>
<a href="https://developer.supervisely.com" target="_blank">
<img src="https://readthedocs.org/projects/supervisely/badge/?version=stable&color=4ec528">
</a>
</p>
---
**Website**: [https://supervisely.com](https://supervisely.com/)
**Supervisely Ecosystem**: [https://ecosystem.supervisely.com](https://ecosystem.supervisely.com/)
**Dev Documentation**: [https://developer.supervisely.com](https://developer.supervisely.com/)
**Source Code of SDK for Python**: [https://github.com/supervisely/supervisely](https://github.com/supervisely/supervisely)
**Supervisely Ecosystem on GitHub**: [https://github.com/supervisely-ecosystem](https://github.com/supervisely-ecosystem)
**Complete video course on YouTube**: [What is Supervisely?](https://supervisely.com/what-is-supervisely/#0)
---
## Table of contents
- [**Complete video course on YouTube**: What is Supervisely?](#complete-video-course-on-youtube-what-is-supervisely)
- [Table of contents](#table-of-contents)
- [Introduction](#introduction)
- [Supervisely Platform 🔥](#supervisely-platform-)
- [Supervisely Ecosystem 🎉](#supervisely-ecosystem-)
- [Development 🧑💻](#development-)
- [What developers can do](#what-developers-can-do)
- [Level 1. HTTP REST API](#level-1-http-rest-api)
- [Level 2. Python scripts for automation and integration](#level-2-python-scripts-for-automation-and-integration)
- [Level 3. Headless apps (without UI)](#level-3-headless-apps-without-ui)
- [Level 4. Apps with interactive UIs](#level-4-apps-with-interactive-uis)
- [Level 5. Apps with UI integrated into labeling tools](#level-5-apps-with-ui-integrated-into-labeling-tools)
- [Principles 🧭](#principles-)
- [Main features 💎](#main-features-)
- [Start in a minute](#start-in-a-minute)
- [Magically simple API](#magically-simple-api)
- [Customization is everywhere](#customization-is-everywhere)
- [Interactive GUI is a game-changer](#interactive-gui-is-a-game-changer)
- [Develop fast with ready UI widgets](#develop-fast-with-ready-ui-widgets)
- [Convenient debugging](#convenient-debugging)
- [Apps can be both private and public](#apps-can-be-both-private-and-public)
- [Single-click deployment](#single-click-deployment)
- [Reliable versioning - releases and branches](#reliable-versioning---releases-and-branches)
- [Supports both Github and Gitlab](#supports-both-github-and-gitlab)
- [App is just a web server, use any technology you love](#app-is-just-a-web-server-use-any-technology-you-love)
- [Built-in cloud development environment (coming soon)](#built-in-cloud-development-environment-coming-soon)
- [Trusted by Fortune 500. Used by 65 000 researchers, developers, and companies worldwide](#trusted-by-fortune-500-used-by-65-000-researchers-developers-and-companies-worldwide)
- [Community 🌎](#community-)
- [Have an idea or ask for help?](#have-an-idea-or-ask-for-help)
- [Contribution 👏](#contribution-)
- [Partnership 🤝](#partnership-)
- [Cite this Project](#cite-this-project)
## Introduction
Every company wants to be sure that its current and future AI tasks are solvable.
The main issue with most solutions on the market is that they build as products. It's a black box developing by some company you don't really have an impact on. As soon as your requirements go beyond basic features offered and you want to customize your experience, add something that is not in line with the software owner development plans or won't benefit other customers, you're out of luck.
That is why **Supervisely is building a platform** instead of a product.
### [Supervisely Platform 🔥](https://supervisely.com/)
<a href="https://supervisely.com/">
<img src="https://user-images.githubusercontent.com/73014155/178843741-996aff24-7ceb-4e3e-88fe-1c19ccd9a757.png" style="max-width:100%;"
alt="Supervisely Platform">
</a>
You can think of [Supervisely](https://supervisely.com/) as an Operating System available via Web Browser to help you solve Computer Vision tasks. The idea is to unify all the relevant tools within a single [Ecosystem](https://ecosystem.supervisely.com/) of apps, tools, UI widgets and services that may be needed to make the AI development process as smooth and fast as possible.
More concretely, Supervisely includes the following functionality:
* Data labeling for images, videos, 3D point cloud and volumetric medical images (dicom)
* Data visualization and quality control
* State-Of-The-Art Deep Learning models for segmentation, detection, classification and other tasks
* Interactive tools for model performance analysis
* Specialized Deep Learning models to speed up data labeling (aka AI-assisted labeling)
* Synthetic data generation tools
* Instruments to make it easier to collaborate for data scientists, data labelers, domain experts and software engineers
### [Supervisely Ecosystem](https://ecosystem.supervisely.com/) 🎉
<a href="https://ecosystem.supervisely.com/">
<img src="https://user-images.githubusercontent.com/73014155/178843764-a92b7ad4-0cce-40ce-b849-17b49c1e1ad3.png" style="max-width:100%;"
alt="Supervisely Platform">
</a>
The simplicity of creating Supervisely Apps has already led to the development of [hundreds of applications](https://ecosystem.supervisely.com/), ready to be run within a single click in a web browser and get the job done.
Label your data, perform quality assurance, inspect every aspect of your data, collaborate easily, train and apply state-of-the-art neural networks, integrate custom models, automate routine tasks and more - like in a real AppStore, there should be an app for everything.
## [Development](https://developer.supervisely.com/) 🧑💻
Supervisely provides the foundation for integration, customization, development and running computer vision applications to address your custom tasks - just like in OS, like Windows or MacOS.
### What developers can do
There are different levels of integration, customization, and automation:
1. [HTTP REST API](#level-1-http-rest-api)
2. [Python scripts for automation and integration](#level-2-python-scripts-for-automation-and-integration)
3. [Headless apps (without UI)](#level-3-headless-apps-without-ui)
4. [Apps with interactive UIs](#level-4-apps-with-interactive-uis)
5. [Apps with UIs integrated into labeling tools](#level-5-apps-with-ui-integrated-into-labeling-tools)
#### Level 1. HTTP REST API
Supervisely has a rich [HTTP REST API](https://api.docs.supervisely.com/) that covers basically every action, you can do manually. You can use **any programming language** and **any development environment** to extend and customize your Supervisely experience.
ℹ️ For Python developers, we recommend using our [Python SDK](https://supervisely.readthedocs.io/en/latest/sdk\_packages.html) because it wraps up all API methods and can save you a lot of time with built-in error handling, network re-connection, response validation, request pagination, and so on.
<details>
<summary>cURL example</summary>
There's no easier way to kick the tires than through [cURL](http://curl.haxx.se/). If you are using an alternative client, note that you are required to send a valid header in your request.
Example:
```bash
curl -H "x-api-key: <your-token-here>" https://app.supervisely.com/public/api/v3/projects.list
```
As you can see, URL starts with `https://app.supervisely.com`. It is for Community Edition. For Enterprise Edition you have to use your custom server address.
</details>
#### Level 2. Python scripts for automation and integration
[Supervisely SDK for Python](https://supervisely.readthedocs.io/en/latest/sdk\_packages.html) is specially designed to speed up development, reduce boilerplate, and lets you do anything in a few lines of Python code with Supervisely Annotatation JSON format, communicate with the platform, import and export data, manage members, upload predictions from your models, etc.
<details>
<summary>Python SDK example</summary>
Look how it is simple to communicate with the platform from your python script.
```python
import supervisely as sly
# authenticate with your personal API token
api = sly.Api.from_env()
# create project and dataset
project = api.project.create(workspace_id=123, name="demo project")
dataset = api.dataset.create(project.id, "dataset-01")
# upload data
image_info = api.image.upload_path(dataset.id, "img.png", "/Users/max/img.png")
api.annotation.upload_path(image_info.id, "/Users/max/ann.json")
# download data
img = api.image.download_np(image_info.id)
ann = api.annotation.download_json(image_info.id)
```
</details>
#### Level 3. Headless apps (without UI)
Create python apps to automate routine and repetitive tasks, share them within your organization, and provide an easy way to use them for end-users without coding background. Headless apps are just python scripts that can be run from a context menu.
It is simple and suitable for the most basic tasks and use-cases, for example:
* import and export in custom format ([example1](https://ecosystem.supervisely.com/apps/import-images-groups), [example2](https://ecosystem.supervisely.com/apps/export-as-masks), [example3](https://ecosystem.supervisely.com/apps/export-to-pascal-voc), [example4](https://ecosystem.supervisely.com/apps/render-video-labels-to-mp4))
* assets transformation ([example1](https://ecosystem.supervisely.com/apps/rasterize-objects-on-images), [example2](https://ecosystem.supervisely.com/apps/resize-images), [example3](https://ecosystem.supervisely.com/apps/change-video-framerate), [example4](https://ecosystem.supervisely.com/apps/convert\_ptc\_to\_ptc\_episodes))
* users management ([example1](https://ecosystem.supervisely.com/apps/invite-users-to-team-from-csv), [example2](https://ecosystem.supervisely.com/apps/create-users-from-csv), [example3](https://ecosystem.supervisely.com/apps/export-activity-as-csv))
* deploy special models for AI-assisted labeling ([example1](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Fritm-interactive-segmentation%2Fsupervisely), [example2](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Ftrans-t%2Fsupervisely%2Fserve), [example3](https://ecosystem.supervisely.com/apps/volume-interpolation))
#### Level 4. Apps with interactive UIs
Interactive interfaces and visualizations are the keys to building and improving AI solutions: from custom data labeling to model training. Such apps open up opportunities to customize Supervisely platform to any type of task in Computer Vision, implement data and models workflows that fit your organization's needs, and even build vertical solutions for specific industries on top of it.
<a href="https://ecosystem.supervisely.com/apps/dev-smart-tool-batched">
<img src="https://user-images.githubusercontent.com/73014155/178845451-8350a6d7-f318-4f5b-a9ee-4b871016e2e4.gif" style="max-width:100%;"
alt="[This interface is completely based on python in combination with easy-to-use Supervisely UI widgets (Batched SmartTool app for AI assisted object segmentations)">
</a>
Here are several examples:
* custom labeling interfaces with AI assistance for [images](https://ecosystem.supervisely.com/apps/dev-smart-tool-batched) and [videos](https://ecosystem.supervisely.com/apps/batched-smart-tool-for-videos)
* [interactive model performance analysis](https://ecosystem.supervisely.com/apps/semantic-segmentation-metrics-dashboard)
* [interactive NN training dashboard](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Fmmsegmentation%2Ftrain)
* [data exploration](https://ecosystem.supervisely.com/apps/action-recognition-stats) and [visualization](https://ecosystem.supervisely.com/apps/objects-thumbnails-preview-by-class) apps
* [vertical solution](https://ecosystem.supervisely.com/collections/supervisely-ecosystem%2Fgl-metric-learning%2Fsupervisely%2Fretail-collection) for labeling products on shelves in retail
* inference interfaces [in labeling tools](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Fnn-image-labeling%2Fannotation-tool); for [images](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Fnn-image-labeling%2Fproject-dataset), [videos](https://ecosystem.supervisely.com/apps/apply-nn-to-videos-project) and [point clouds](https://ecosystem.supervisely.com/apps/apply-det3d-to-project-dataset); for [model ensembles](https://ecosystem.supervisely.com/apps/apply-det-and-cls-models-to-project)
#### Level 5. Apps with UI integrated into labeling tools
There is no single labeling tool that fits all tasks. Labeling tool has to be designed and customized for a specific task to make the job done in an efficient manner. Supervisely apps can be smoothly integrated into labeling tools to deliver amazing user experience (including multi tenancy) and annotation performance.
<a href="https://ecosystem.supervisely.com/apps/supervisely-ecosystem%252Fgl-metric-learning%252Fsupervisely%252Flabeling-tool">
<img src="https://user-images.githubusercontent.com/12828725/179206991-1c76f61d-b88a-4a2b-9116-d87fb1ed9d0e.png" style="max-width:100%;"
alt="[AI assisted retail labeling app is integrated into labeling tool and can communicate with it via web sockets)">
</a>
Here are several examples:
* apps designed for custom labeling workflows ([example1](https://ecosystem.supervisely.com/apps/visual-tagging), [example2](https://ecosystem.supervisely.com/apps/review-labels-side-by-side))
* NN inference is integrated for labeling automation and model predictions analysis ([example](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Fnn-image-labeling%2Fannotation-tool))
* industry-specific labeling tool: annotation of thousands of product types on shelves with AI assistance ([retail collection](https://ecosystem.supervisely.com/collections/supervisely-ecosystem%2Fgl-metric-learning%2Fsupervisely%2Fretail-collection), [labeling app](https://ecosystem.supervisely.com/apps/ai-assisted-classification))
### Principles 🧭
Development for Supervisely builds upon these five principles:
* All in **pure Python** and build on top of your favourites libraries (opencv, requests, fastapi, pytorch, imgaug, etc ...) - easy for python developers and data scientists to build and share apps with teammates and the ML community.
* No front‑end experience is required - build **powerful** and **interactive** web-based GUI apps using the comprehensive library of ready-to-use UI widgets and components.
* **Easy to learn, fast to code,** and **ready for production**. SDK provides a simple and intuitive API by having complexity "under the hood". Every action can be done just in a few lines of code. You focus on your task, Supervisely will handle everything else - interfaces, databases, permissions, security, cloud or self-hosted deployment, networking, data storage, and many more. Supervisely has solid testing, documentation, and support.
* Everything is **customizable** - from labeling interfaces to neural networks. The platform has to be customized and extended to perfectly fit your tasks and requirements, not vice versa. Hundreds of examples cover every scenario and can be found in our [ecosystem of apps](https://ecosystem.supervisely.com/).
* Apps can be both **open-sourced or private**. All apps made by Supervisely team are [open-sourced](https://github.com/supervisely-ecosystem). Use them as examples, just fork and modify the way you want. At the same time, customers and community users can still develop private apps to protect their intellectual property.
## Main features 💎
- [**Complete video course on YouTube**: What is Supervisely?](#complete-video-course-on-youtube-what-is-supervisely)
- [Table of contents](#table-of-contents)
- [Introduction](#introduction)
- [Supervisely Platform 🔥](#supervisely-platform-)
- [Supervisely Ecosystem 🎉](#supervisely-ecosystem-)
- [Development 🧑💻](#development-)
- [What developers can do](#what-developers-can-do)
- [Level 1. HTTP REST API](#level-1-http-rest-api)
- [Level 2. Python scripts for automation and integration](#level-2-python-scripts-for-automation-and-integration)
- [Level 3. Headless apps (without UI)](#level-3-headless-apps-without-ui)
- [Level 4. Apps with interactive UIs](#level-4-apps-with-interactive-uis)
- [Level 5. Apps with UI integrated into labeling tools](#level-5-apps-with-ui-integrated-into-labeling-tools)
- [Principles 🧭](#principles-)
- [Main features 💎](#main-features-)
- [Start in a minute](#start-in-a-minute)
- [Magically simple API](#magically-simple-api)
- [Customization is everywhere](#customization-is-everywhere)
- [Interactive GUI is a game-changer](#interactive-gui-is-a-game-changer)
- [Develop fast with ready UI widgets](#develop-fast-with-ready-ui-widgets)
- [Convenient debugging](#convenient-debugging)
- [Apps can be both private and public](#apps-can-be-both-private-and-public)
- [Single-click deployment](#single-click-deployment)
- [Reliable versioning - releases and branches](#reliable-versioning---releases-and-branches)
- [Supports both Github and Gitlab](#supports-both-github-and-gitlab)
- [App is just a web server, use any technology you love](#app-is-just-a-web-server-use-any-technology-you-love)
- [Built-in cloud development environment (coming soon)](#built-in-cloud-development-environment-coming-soon)
- [Trusted by Fortune 500. Used by 65 000 researchers, developers, and companies worldwide](#trusted-by-fortune-500-used-by-65-000-researchers-developers-and-companies-worldwide)
- [Community 🌎](#community-)
- [Have an idea or ask for help?](#have-an-idea-or-ask-for-help)
- [Contribution 👏](#contribution-)
- [Partnership 🤝](#partnership-)
- [Cite this Project](#cite-this-project)
### Start in a minute
Supervisely's open-source SDK and app framework are straightforward to get started with. It's just a matter of:
```
pip install supervisely
```
### Magically simple API
[Supervisely SDK for Python](https://supervisely.readthedocs.io/en/latest/sdk\_packages.html) is simple, intuitive, and can save you hours. Reduce boilerplate and build custom integrations in a few lines of code. It has never been so easy to communicate with the platform from python.
```python
# authenticate with your personal API token
api = sly.Api.from_env()
# create project and dataset
project = api.project.create(workspace_id=123, name="demo project")
dataset = api.dataset.create(project.id, "dataset-01")
# upload data
image_info = api.image.upload_path(dataset.id, "img.png", "/Users/max/img.png")
api.annotation.upload_path(image_info.id, "/Users/max/ann.json")
# download data
img = api.image.download_np(image_info.id)
ann = api.annotation.download_json(image_info.id)
```
### Customization is everywhere
Customization is the only way to cover all tasks in Computer Vision. Supervisely allows to customizing everything from labeling interfaces and context menus to training dashboards and inference interfaces. Check out our [Ecosystem of apps](https://ecosystem.supervisely.com/) to find inspiration and examples for your next ML tool.
### Interactive GUI is a game-changer
The majority of Python programs are "command line" based. While highly experienced programmers don't have problems with it, other tech people and end-users do. This creates a digital divide, a "GUI Gap". App with graphic user interface (GUI) becomes more approachable and easy to use to a wider audience. And finally, some tasks are impossible to solve without a GUI at all.
Imagine, how it will be great if all ML tools and repositories have an interactive GUI with the RUN button ▶️. It will take minutes to start working with a top Deep Learning framework instead of spending weeks running it on your data.
🎯 Our ambitious goal is to make it possible.
<a href="https://ecosystem.supervisely.com/apps/semantic-segmentation-metrics-dashboard">
<img src="https://user-images.githubusercontent.com/73014155/178846370-ae86dd3c-e08d-4df2-871b-d342bf7ba370.gif" style="max-width:100%;"
alt="Semantic segmentation metrics app">
</a>
### Develop fast with ready UI widgets
Hundreds of interactive UI widgets and components are ready for you. Just add to your program and populate with the data. Python devs don't need to have any front‑end experience, in our developer portal you will find needed guides, examples, and tutorials. We support the following UI widgets:
1. [Widgets made by Supervisely](https://developer.supervisely.com/app-development/widgets) specifically for computer vision tasks, like rendering galleries of images with annotations, playing videos forward and backward with labels, interactive confusion matrices, tables, charts, ...
2. [Element widgets](https://element.eleme.io/1.4/#/en-US/component/button) - Vue 2.0 based component library
3. [Plotly](https://plotly.com/python/) Graphing Library for Python
4. [Develop your own custom widgets](https://developer.supervisely.com/app-development/advanced/how-to-make-your-own-widget)
Supervisely team makes most of its apps publically available on [GitHub](https://github.com/supervisely-ecosystem). Use them as examples for your future apps: fork, modify, and copy-paste code snippets.
### Convenient debugging
Supervisely is made by data scientists for data scientists. We trying to lower barriers and make a friendly development environment. Especially we care about debugging as one of the most crucial steps.
Even in complex scenarios, like developing a GUI app integrated into a labeling tool, we keep it simple - use breakpoints in your favorite IDE to catch callbacks, step through the program and see live updates without page reload. As simple as that! Supervisely handles everything else - WebSockets, authentication, Redis, RabitMQ, Postgres, ...
Watch the video below, how we debug [the app](https://ecosystem.supervisely.com/apps/supervisely-ecosystem%2Fnn-image-labeling%2Fannotation-tool) that applies NN right inside the labeling interface.
<a href="https://youtu.be/fOnyL8YHOBM">
<img src="https://user-images.githubusercontent.com/12828725/179207006-bcdd0922-21c1-4958-86e7-d532fbf7c974.png" style="max-width:100%;">
</a>
### Apps can be both private and public
All apps made by Supervisely team are [open-source](https://github.com/supervisely-ecosystem). Use them as examples: find on [GitHub](https://github.com/supervisely-ecosystem), fork and modify them the way you want. At the same time, customers and community users can still develop private apps to protect their intellectual property.
<a href="https://youtu.be/Kyuc-lZu_tg">
<img src="https://user-images.githubusercontent.com/12828725/179207014-55659b39-0f58-42db-96e3-8063f1e6ad5d.png" style="max-width:100%;">
</a>
### Single-click deployment
Supervisely app is a git repository. Just provide the link to your git repo, Supervisely will handle everything else. Now you can press `Run` button in front of your app and start it on any computer with [Supervisely Agent](https://youtu.be/aDqQiYycqyk).
### Reliable versioning - releases and branches
Users run your app on the latest stable release, and you can develop and test new features in parallel - just use git releases and branches. Supervisely automatically pull updates from git, even if the new version of an app has a bug, don't worry - users can select and run the previous version in a click.
<a href="https://youtu.be/ngoHfM98R8k">
<img src="https://user-images.githubusercontent.com/12828725/179207015-d5f839a6-907b-4469-9f86-950ee348024e.png" style="max-width:100%;">
</a>
### Supports both Github and Gitlab
Since Supervisely app is just a git repository, we support public and private repos from the most popular hosting platforms in the world - GitHub and GitLab.
### App is just a web server, use any technology you love
Supervisely SDK for Python provides the simplest way for python developers and data scientists to build interactive GUI apps of any complexity. Python is a recommended language for developing Supervisely apps, but not the only one. You can use any language or any technology you love, any web server can be deployed on top of the platform.
For example, even [Visual Studio Code for web](https://github.com/coder/code-server) can be run as an app (see video below).
### Built-in cloud development environment (coming soon)
In addition to the common way of development in your favorite IDE on your local computer or laptop, cloud development support will be integrated into Supervisely and **released soon** to speed up development, standardize dev environments, and lower barriers for beginners.
How will it work? Just connect your computer to your Supervisely instance and run IDE app ([JupyterLab](https://jupyter.org/) and [Visual Studio Code for web](https://github.com/coder/code-server)) to start coding in a minute. We will provide a large number of template apps that cover the most popular use cases.
<a href="https://youtu.be/ptHJsdolHHk">
<img src="https://user-images.githubusercontent.com/73014155/178956713-0de05a39-3ecc-41b2-a46e-54d3a23d4e64.png" style="max-width:100%;">
</a>
### Trusted by Fortune 500. Used by 65 000 researchers, developers, and companies worldwide
Supervisely helps companies and researchers all over the world to build their computer vision solutions in various industries from self-driving and agriculture to medicine. Join our [Community Edition](https://app.supervisely.com/) or request [Enterprise Edition](https://supervisely.com/enterprise) for your organization.
## Community 🌎
Join our constantly growing [Supervisely community](https://app.supervisely.com/) with more than 65k+ users.
#### Have an idea or ask for help?
If you have any questions, ideas or feedback please:
1. [Suggest a feature or idea](https://ideas.supervisely.com/), or [give a technical feedback ](https://github.com/supervisely/supervisely/issues)
2. [Join our slack](https://supervisely.com/slack)
3. [Contact us](https://supervisely.com/contact-us)
Your feedback 👍 helps us a lot and we appreciate it
## Contribution 👏
Want to help us bring Computer Vision R\&D to the next level? We encourage you to participate and speed up R\&D for thousands of researchers by
* building and expanding Supervisely Ecosystem with us
* integrating to Supervisley and sharing your ML tools and research with the entire ML community
## Partnership 🤝
We are happy to expand and increase the value of Supervisely Ecosystem with additional technological partners, researchers, developers, and value-added resellers.
Feel free to [contact us](https://supervisely.com/contact-us) if you have
* ML service or product
* unique domain expertise
* vertical solution
* valuable repositories and tools that solve the task
* custom NN models and data
Let's discuss the ways of working together, particularly if we have joint interests, technologies and customers.
## Cite this Project
If you use this project in a research, please cite it using the following BibTeX:
```
@misc{ supervisely,
title = { Supervisely Computer Vision platform },
type = { Computer Vision Tools },
author = { Supervisely },
howpublished = { \url{ https://supervisely.com } },
url = { https://supervisely.com },
journal = { Supervisely Ecosystem },
publisher = { Supervisely },
year = { 2023 },
month = { jul },
note = { visited on 2023-07-20 },
}
```
| text/markdown | Supervisely | support@supervisely.com | Max Kolomeychenko | null | null | null | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Natural Language :: English",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language ::... | [] | https://github.com/supervisely/supervisely | null | >=3.8 | [] | [] | [] | [
"cachetools<=5.5.0,>=4.2.3",
"numpy<=2.3.3,>=1.19",
"opencv-python<5.0.0.0,>=4.6.0.66",
"PTable<1.0.0,>=0.9.2",
"pillow<=10.4.0,>=5.4.1",
"python-json-logger<=3.0.1,>=0.1.11",
"requests<3.0.0,>=2.27.1",
"requests-toolbelt>=0.9.1",
"Shapely<=2.1.2,>=1.7.1",
"bidict<1.0.0,>=0.21.2",
"varname<1.0.0... | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-18T10:25:38.845276 | supervisely-6.73.532.tar.gz | 2,248,052 | 74/37/aba9c5257bcd3eacc29c7f97e35d7a99cc7070660e3253e0667f24d51e98/supervisely-6.73.532.tar.gz | source | sdist | null | false | c3412f427352c3ec5ed15aedb3bbd266 | da6aa9451e130cfe7c32f5b3984d33b86dace35c054d4e287afd8262049a543e | 7437aba9c5257bcd3eacc29c7f97e35d7a99cc7070660e3253e0667f24d51e98 | null | [
"LICENSE"
] | 652 |
2.4 | container-magic | 1.12.0 | A tool for rapidly creating containerised development environments | <div align="center">
<img src="https://raw.githubusercontent.com/markhedleyjones/container-magic-artwork/main/sparkles/original-vector.svg" alt="Container Magic - Sparkles the Otter" width="300"/>
# container-magic
**Rapidly create containerised development environments**
Configure once in YAML, use anywhere with Docker or Podman
[](https://pypi.org/project/container-magic/)
[](https://pypi.org/project/container-magic/)
[](https://github.com/markhedleyjones/container-magic/actions/workflows/ci.yml)
[](https://opensource.org/licenses/MIT)
[](https://github.com/astral-sh/ruff)
</div>
## What It Does
Container-magic takes a single YAML configuration file and generates:
1. A **Dockerfile** with multi-stage builds
2. A **Justfile** for development (with live workspace mounting)
3. Standalone **build.sh** and **run.sh** scripts for production
The generated files are committed to your repository, so anyone can use your project with just `docker` or `podman` — no need to install container-magic.
## Quick Start
```bash
pip install container-magic
cm init python my-project
cd my-project
just build
just run python --version
```
A minimal `cm.yaml`:
```yaml
project:
name: my-project
workspace: workspace
stages:
base:
from: python:3.11-slim
packages:
apt:
- git
- build-essential
pip:
- numpy
- pandas
development:
from: base
production:
from: base
```
## Key Features
* **YAML configuration** — Single source of truth for your container setup
* **Transparent execution** — Run commands from anywhere in your repo with automatic path translation
* **Custom commands** — Define commands once, use in both dev and prod
* **Smart features** — GPU, display (X11/Wayland), and audio support
* **Multi-stage builds** — Separate base, development, and production stages
* **Cached assets** — Download models/datasets once, reuse across builds
* **Standalone scripts** — Production needs only docker/podman
## Documentation
Full documentation is available at **[markhedleyjones.com/container-magic](https://markhedleyjones.com/container-magic/)**.
| Page | Contents |
|------|----------|
| [Getting Started](https://markhedleyjones.com/container-magic/getting-started/) | Installation, first project, workflow, project structure |
| [Configuration](https://markhedleyjones.com/container-magic/configuration/) | Full YAML reference — project, runtime, user, stages, commands |
| [Build Steps](https://markhedleyjones.com/container-magic/build-steps/) | All 10 built-in steps, custom commands, defaults, ordering |
| [Cached Assets](https://markhedleyjones.com/container-magic/cached-assets/) | Asset downloading, caching, and cache management |
| [User Handling](https://markhedleyjones.com/container-magic/user-handling/) | Dev vs prod users, copy ownership, permissions |
| [Troubleshooting](https://markhedleyjones.com/container-magic/troubleshooting/) | Common issues and solutions |
## Contributing
Container-magic is in early development. Contributions and feedback welcome!
| text/markdown | null | Mark Hedley Jones <mark@hedleyjones.com> | null | null | MIT | null | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Py... | [] | null | null | >=3.8 | [] | [] | [] | [
"pyyaml>=6.0",
"jinja2>=3.1.0",
"click>=8.1.0",
"pydantic>=2.0.0",
"requests>=2.31.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"black>=23.0.0; extra == \"dev\"",
"ruff>=0.1.0; extra == \"dev\"",
"python-semantic-release>=8.0.0; extra == \"dev\"",
"mkdocs-materia... | [] | [] | [] | [
"Homepage, https://github.com/markhedleyjones/container-magic",
"Repository, https://github.com/markhedleyjones/container-magic",
"Issues, https://github.com/markhedleyjones/container-magic/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:24:21.566294 | container_magic-1.12.0.tar.gz | 30,814 | 89/d8/05f15d302b7c3197849323e1f96777892fff73dd2770c845d7869aef8441/container_magic-1.12.0.tar.gz | source | sdist | null | false | a80d077e3e8367ba0442900a844f60fc | 6d0c95673f3c4ed410e548ec2511a3feea0d96568360a9c560888079fa528ef0 | 89d805f15d302b7c3197849323e1f96777892fff73dd2770c845d7869aef8441 | null | [
"LICENSE"
] | 260 |
2.4 | cli-helpers | 2.10.1 | Helpers for building command-line apps | ===========
CLI Helpers
===========
.. image:: https://ci.appveyor.com/api/projects/status/37a1ri2nbcp237tr/branch/main?svg=true
:target: https://ci.appveyor.com/project/dbcli/cli-helpers
.. image:: https://codecov.io/gh/dbcli/cli_helpers/branch/main/graph/badge.svg
:target: https://codecov.io/gh/dbcli/cli_helpers
.. image:: https://img.shields.io/pypi/v/cli_helpers.svg?style=flat
:target: https://pypi.python.org/pypi/cli_helpers
.. start-body
CLI Helpers is a Python package that makes it easy to perform common tasks when
building command-line apps. It's a helper library for command-line interfaces.
Libraries like `Click <http://click.pocoo.org/5/>`_ and
`Python Prompt Toolkit <https://python-prompt-toolkit.readthedocs.io/en/latest/>`_
are amazing tools that help you create quality apps. CLI Helpers complements
these libraries by wrapping up common tasks in simple interfaces.
CLI Helpers is not focused on your app's design pattern or framework -- you can
use it on its own or in combination with other libraries. It's lightweight and
easy to extend.
What's included in CLI Helpers?
- Prettyprinting of tabular data with custom pre-processing
- Config file reading/writing
.. end-body
Read the documentation at http://cli-helpers.rtfd.io
| text/x-rst | dbcli | thomas@roten.us | null | null | null | null | [
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: Unix",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Topic :: Software Development",
"Topic ... | [] | https://github.com/dbcli/cli_helpers | null | >=3.6 | [] | [] | [] | [
"configobj>=5.0.5",
"tabulate[widechars]>=0.9.0",
"Pygments>=1.6; extra == \"styles\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.3 | 2026-02-18T10:24:10.926847 | cli_helpers-2.10.1.tar.gz | 40,945 | 74/8d/49dcad9f93ef8d18d25370f041a6f752cbbf7cfa28904b18a1b1c830237c/cli_helpers-2.10.1.tar.gz | source | sdist | null | false | 2548712531a0ff00926457e578438b5c | 009e52d35f9ed818daf755608927af37c09848e8b457631b8955ded9e3d5673e | 748d49dcad9f93ef8d18d25370f041a6f752cbbf7cfa28904b18a1b1c830237c | null | [
"LICENSE",
"AUTHORS"
] | 56,364 |
2.4 | iamwho | 0.1.7 | IAM principal analysis: ingress, egress, mutation | # iamwho
[](https://pypi.org/project/iamwho/)
> **iamwho: Static AWS IAM analyzer focused on post-compromise blast radius.**
---
## How iamwho Thinks About Risk
The diagram below illustrates the difference between **access analysis** and **impact analysis**.
- **Access analysis**: Determines whether an action is allowed.
- **Impact analysis**: Identifies what else becomes reachable once an identity is compromised.
*iamwho* analyzes this graph to expose escalation paths and blast-radius expansions that remain hidden when policies are evaluated in isolation.
---
## Why
While most AWS IAM tools focus on the question:
> *Is this action allowed?*
This perspective is incomplete. **iamwho** shifts the focus to a crucial failure mode:
> *If this identity is compromised, what else becomes reachable?*
Recognizing that attackers consider **trust chains**, **permission composition**, and their potential next steps is vital.
| AWS Tool | Primary Focus | Blind Spot |
|:---------|:--------------|:-----------|
| IAM Access Analyzer | External access, unused permissions | Chained trust & role hopping |
| Policy Simulator | Point-in-time authorization | Post-compromise reach |
| Config Rules | Compliance posture | Effective permission composition |
IAM risk rarely resides within a single policy. A role might seem low risk in isolation yet become dangerous when:
- Assumed by another reachable identity
- Grants permissions enabling mutations
- Unlocks additional roles or services
**iamwho** examines these relationships as a graph, making visible the **ingress → egress → mutation** paths that expand the blast radius, even when individual policies appear secure.
---
## What iamwho Does
**iamwho** is a static **AWS IAM security analyzer** that evaluates IAM configurations and trust relationships from an attacker's perspective. It focuses solely on static analysis, without relying on runtime activity, logs, or CloudTrail events.
The tool answers three core questions:
- **INGRESS** — Who can assume this identity?
- **EGRESS** — What does this identity enable?
- **MUTATION** — Can access be escalated or persisted?
**iamwho** is designed for security impact analysis and does not include:
- Runtime detection or IAM activity monitoring.
- Full IAM policy simulation for real-time permission testing.
- Network or secrets analysis outside of IAM configurations.
- Compliance mapping for standards such as CIS, SOC2, etc.
By focusing on these areas, **iamwho** identifies potential vulnerabilities and escalation paths that may not be apparent through isolated policy evaluations, helping to improve your overall security posture.
---
## Installation
```bash
pip install iamwho
```
---
## Quick Start
```bash
pip install iamwho && iamwho analyze arn:aws:iam::123456789012:role/MyRole
```
For development:
```bash
git clone https://github.com/YayoPalacios/iamwho.git
cd iamwho
pip install -e .
```
---
## Requirements
- Python `3.10+`
- AWS credentials configured (env vars or profile)
- IAM read-only permissions for role and policy inspection (e.g. `iam:Get*`, `iam:List*`)
---
## Usage
```bash
# Run all checks
iamwho analyze arn:aws:iam::123456789012:role/MyRole
# Run a specific check
iamwho analyze <role-arn> --check egress
iamwho analyze <role-arn> -c ingress
# Verbose mode (reasoning and remediation hints)
iamwho analyze <role-arn> --verbose
iamwho analyze <role-arn> -v
# JSON output (CI/CD friendly)
iamwho analyze <role-arn> --json
# Fail if findings meet severity threshold (CI/CD gating)
iamwho analyze <role-arn> --fail-on high
iamwho analyze <role-arn> --fail-on critical
# Use a specific AWS profile
AWS_PROFILE=prod iamwho analyze <role-arn>
```
### Example Output
Running with `--verbose` provides reasoning and potential escalation paths:
```text
[HIGH] ! * iam:CreateAccessKey
-> Can create access keys for users
Source: inline:inline-danger
Scope: ALL
[CRIT] ✗ sts:AssumeRole
-> Can assume other IAM roles
Source: inline:inline-danger
Scope: ALL
```
Using `--json` produces structured output suitable for CI/CD and reporting:
```json
{
"role": "MyRole",
"findings": [
{
"check": "mutation",
"severity": "CRITICAL",
"description": "Privilege escalation via sts:AssumeRole",
"path": ["MyRole", "AdminRole"]
}
]
}
```
---
## CI/CD Integration
**iamwho** can block pull requests that introduce risky IAM roles.
### GitHub Actions
Create `.github/workflows/iam-audit.yml`:
```yaml
- name: Analyze IAM Role
run: |
pip install iamwho
iamwho analyze $ROLE_ARN --fail-on high
```
### Severity Gating
| Flag | Behavior |
|------|----------|
| `--fail-on critical` | Fails only on critical findings |
| `--fail-on high` | Fails on high or critical |
| `--fail-on medium` | Fails on medium and above |
| `--fail-on low` | Fails on any finding |
### Required Secrets
| Secret | Description |
|--------|-------------|
| `AWS_ACCESS_KEY_ID` | IAM user access key |
| `AWS_SECRET_ACCESS_KEY` | IAM user secret key |
> The IAM principal requires read-only IAM permissions to inspect roles and attached policies.
---
## Checks
| Check | Question It Answers |
|:------|:--------------------|
| ingress | Who can become this role? |
| egress | What does this role enable? |
| mutation | Can access escalate or persist? |
---
## Risk Levels
| Level | Meaning |
|:------|:--------|
| **CRITICAL** | Enables privilege escalation or long-lived persistence |
| **HIGH** | Expands blast radius across services or roles |
| **MEDIUM** | Enables discovery, staging, or limited lateral movement |
| **LOW** | Read-only or tightly scoped access with minimal composition risk |
---
## Roadmap
- [x] INGRESS analysis (trust policies)
- [x] EGRESS analysis (permissions)
- [x] MUTATION analysis (escalation paths)
- [x] JSON output for CI/CD
- [x] Exit codes for CI gating (`--fail-on`)
- [x] PyPI package release
### Planned
- User and group principal support
- Permission boundary analysis
---
## Documentation
- [Cheatsheet](docs/cheatsheet.md) — quick reference
- [Methodology](docs/methodology.md) — how iamwho reasons about IAM risk
---
## License
iamwho is licensed under the MIT License.
The MIT License permits users to use, copy, modify, and distribute the software with minimal restrictions. The only requirement is to include the original copyright and permission notice in all copies or substantial portions of the software.
This allows you to freely use iamwho in both open-source and proprietary projects.
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"boto3>=1.34",
"rich>=13.0",
"typer>=0.9",
"pytest>=8.0; extra == \"dev\"",
"ruff>=0.4; extra == \"dev\""
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.11.14 | 2026-02-18T10:23:27.003481 | iamwho-0.1.7.tar.gz | 837,390 | db/48/b835a849ba7e86c0c23d4d9f304324cc501eb8399e5b98b8ff1be03deb71/iamwho-0.1.7.tar.gz | source | sdist | null | false | 0b6f4200637efbc5187581c17d91e7d5 | f29758456f39f2b7cca0ab825dd384baa41134f3b4bcb0fb64924aeb1e3b7471 | db48b835a849ba7e86c0c23d4d9f304324cc501eb8399e5b98b8ff1be03deb71 | MIT | [
"LICENSE"
] | 261 |
2.4 | muban-cli | 1.3.8 | Command-line interface for Muban Document Generation Service | # Muban CLI
A robust command-line interface for the **Muban Document Generation Service**. Manage JasperReports templates and generate documents directly from your terminal.
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
## Features
- **Graphical User Interface** - Optional PyQt6-based GUI for visual template management and document generation
- **Secure Authentication** - JWT token-based auth with password or OAuth2 client credentials flow
- **Template Management** - List, upload, download, and delete templates
- **Template Packaging** - Package JRXML templates with all dependencies (images, subreports) into ZIP
- **Document Generation** - Generate PDF, XLSX, DOCX, RTF, and HTML documents
- **Async Processing** - Submit bulk document generation jobs and monitor progress
- **Search & Filter** - Search templates and filter audit logs
- **Audit & Monitoring** - Access audit logs and security dashboards (admin)
- **Multiple Output Formats** - Table, JSON, and CSV for easy data export
- **Automation Ready** - Perfect for CI/CD pipelines with service account support
- **Cross-Platform** - Works on Windows, macOS, and Linux
## Installation
### From PyPI (Recommended)
```bash
pip install muban-cli
```
### From Source
```bash
git clone https://github.com/muban/muban-cli.git
cd muban-cli
pip install -e .
```
### GUI Installation
To use the graphical user interface, install with GUI extras:
```bash
pip install muban-cli[gui]
```
This installs PyQt6 and enables the `muban-gui` command.
### Development Installation
```bash
pip install -e ".[dev]"
```
## Quick Start
### 1. Configure the Server
```bash
# Interactive setup
muban configure
# Or with command-line options
muban configure --server https://api.muban.me
```
### 2. Login with Your Credentials
```bash
# Interactive login (prompts for username/password)
muban login
# Or with command-line options
muban login --username your@email.com
```
### 3. List Available Templates
```bash
muban list
```
### 4. Generate a Document
```bash
muban generate TEMPLATE_ID -p title="Monthly Report" -p date="2025-01-08"
```
## Unauthenticated Access
If your Muban API server has authentication disabled (common in development or internal deployments), you can use the CLI without logging in:
```bash
# Configure the server only (no login required)
muban configure --server http://localhost:8080
# Start using the CLI immediately
muban list
muban generate TEMPLATE_ID -p name="Test"
```
The CLI automatically detects when no credentials are configured and sends requests without an `Authorization` header.
## Configuration
### Configuration File
Configuration is stored in `~/.muban/config.json`. JWT tokens are stored separately in `~/.muban/credentials.json` with restricted permissions.
### Environment Variables
| Variable | Description |
| -------- | ----------- |
| `MUBAN_TOKEN` | JWT Bearer token (obtained via `muban login`) |
| `MUBAN_SERVER_URL` | API server URL (default: <https://api.muban.me>) |
| `MUBAN_AUTH_SERVER_URL` | OAuth2/IdP token endpoint (if different from API server) |
| `MUBAN_CLIENT_ID` | OAuth2 Client ID (for client credentials flow) |
| `MUBAN_CLIENT_SECRET` | OAuth2 Client Secret (for client credentials flow) |
| `MUBAN_TIMEOUT` | Request timeout in seconds |
| `MUBAN_MAX_RETRIES` | Max retries for transient errors (default: 3, set to 0 to disable) |
| `MUBAN_VERIFY_SSL` | Enable/disable SSL verification |
| `MUBAN_CONFIG_DIR` | Custom configuration directory |
Environment variables take precedence over configuration files.
## Commands Reference
### Authentication
```bash
# Login with credentials (interactive)
muban login
# Login with username provided
muban login --username admin@example.com
# Login with custom server
muban login --server https://api.muban.me
# Login with OAuth2 Client Credentials (for CI/CD / service accounts)
muban login --client-credentials
muban login -c --client-id my-client --client-secret secret123
# Login with external IdP (ADFS, Azure AD, Keycloak)
muban login -c --auth-server https://adfs.company.com/adfs/oauth2/token
# Skip SSL verification (development only)
muban login --no-verify-ssl
# Check authentication status (shows token expiry)
muban whoami
# Manually refresh access token
muban refresh
# Logout (clear all tokens)
muban logout
```
**Token Refresh:**
- If the server provides a refresh token, it's automatically stored
- The CLI automatically refreshes expired tokens when making API requests
- Use `muban refresh` to manually refresh before expiration
- Use `muban whoami` to see token expiration time
### Configuration Commands
```bash
# Interactive configuration
muban configure
# Set server URL
muban configure --server https://api.muban.me
# Set auth server (if different from API server)
muban configure --auth-server https://auth.muban.me
# Set default author for template uploads
muban configure --author "John Doe"
# Enable auto-upload after packaging
muban configure --auto-upload
# Disable auto-upload
muban configure --no-auto-upload
# Show current configuration
muban configure --show
# Clear all configuration
muban config-clear
```
### Template Management
```bash
# List all templates
muban list
muban list --search "invoice" --format json
muban list --format csv > templates.csv # Export to CSV
muban list --page 2 --size 50
# Search templates
muban search "quarterly report"
# Get template details
muban get TEMPLATE_ID
muban get TEMPLATE_ID --params # Show parameters
muban get TEMPLATE_ID --fields # Show fields
# Export template details for Excel (CSV unified format)
muban get TEMPLATE_ID --params --fields --format csv > template.csv
# Export as single JSON object with nested parameters/fields
muban get TEMPLATE_ID --params --fields --format json
# Upload a template (ZIP format)
muban push report.zip --name "Monthly Report" --author "John Doe"
muban push invoice.zip -n "Invoice" -a "Finance Team" -m "Standard invoice template"
# Download a template
muban pull TEMPLATE_ID
muban pull TEMPLATE_ID -o ./templates/report.zip
# Delete a template
muban delete TEMPLATE_ID
muban delete TEMPLATE_ID --yes # Skip confirmation
```
### Template Packaging
The `package` command analyzes a JRXML template file and packages it with all its dependencies (images, subreports) into a ZIP file ready for upload.
```bash
# Package a template (creates template.zip)
muban package template.jrxml
# Specify output path
muban package template.jrxml -o package.zip
# Dry run - analyze without creating ZIP
muban package template.jrxml --dry-run
# Verbose output - show all discovered assets
muban package template.jrxml --dry-run -v
# Custom REPORTS_DIR parameter name
muban package template.jrxml --reports-dir-param TEMPLATE_PATH
# Bundle custom fonts (creates fonts.xml for JasperReports)
muban package template.jrxml \
--font-file fonts/OpenSans-Regular.ttf --font-name "Open Sans" --font-face normal --embedded \
--font-file fonts/OpenSans-Bold.ttf --font-name "Open Sans" --font-face bold --embedded
# Multiple font families
muban package template.jrxml \
--font-file arial.ttf --font-name "Arial Custom" --font-face normal --embedded \
--font-file times.ttf --font-name "Times Custom" --font-face normal --no-embedded
# Use existing fonts.xml file instead of building font list
muban package template.jrxml --fonts-xml path/to/fonts.xml
# Package and upload in one step
muban package template.jrxml --upload
# Package and upload with custom name/author
muban package template.jrxml --upload --name "My Report" --author "John Doe"
```
**Features:**
- **Automatic Asset Discovery** - Parses JRXML to find all referenced images and subreports
- **Recursive Subreport Analysis** - Analyzes subreport `.jrxml` files to include their dependencies
- **Font Bundling** - Include custom fonts with auto-generated `fonts.xml` or use an existing one via `--fonts-xml`
- **REPORTS_DIR Resolution** - Respects the `REPORTS_DIR` parameter default value for path resolution
- **Dynamic Directory Support** - Includes all files from directories with dynamic filenames (`$P{DIR} + "path/" + $P{filename}`)
- **URL Skipping** - Automatically skips remote resources (http://, https://, etc.)
- **POSIX Path Handling** - Correctly handles path concatenation (e.g., `"../" + "/img"` → `"../img"`)
- **Auto-Upload** - Optionally upload immediately after packaging with `--upload` flag or enable globally via `muban configure --auto-upload`
**Example Output (verbose mode):**
```text
ℹ Packaging: invoice.jrxml
ℹ Working directory: /projects/templates
Main template:
invoice.jrxml
Assets found: 8
✓ subreports/header.jasper
✓ subreports/footer.jasper
✓ assets/img/logo.png
✓ assets/img/signature.png [from subreports/header.jrxml]
✓ assets/img/faksymile/* (dynamic: $P{signatureFile}, 3 files included)
✗ assets/img/missing.png (missing)
⚠ Dynamic asset: assets/img/faksymile/* - included all 3 files from directory
⚠ Asset not found: assets/img/missing.png (referenced in invoice.jrxml)
✓ Created: invoice.zip
```
**Typical Workflow:**
```bash
# 1. Package the template
muban package my-report.jrxml -o my-report.zip
# 2. Upload to the server
muban push my-report.zip --name "My Report" --author "Developer"
```
### Document Generation
```bash
# Basic generation
muban generate TEMPLATE_ID -p title="Sales Report"
# Multiple parameters
muban generate TEMPLATE_ID -p title="Report" -p year=2025 -p amount=15750.25
# Different output formats
muban generate TEMPLATE_ID -F xlsx -o report.xlsx
muban generate TEMPLATE_ID -F docx -o report.docx
muban generate TEMPLATE_ID -F html -o report.html
# Using parameter file
muban generate TEMPLATE_ID --params-file params.json
# Using JSON data source
muban generate TEMPLATE_ID --data-file data.json
# PDF options
muban generate TEMPLATE_ID --pdf-pdfa PDF/A-1b --locale pl_PL
muban generate TEMPLATE_ID --pdf-password secret123
# Output options
muban generate TEMPLATE_ID -o ./output/report.pdf --filename "Sales_Report_Q4"
```
**Parameter File Format (params.json):**
```json
{
"title": "Monthly Sales Report",
"year": 2025,
"department": "Finance"
}
```
Or as a list:
```json
[
{"name": "title", "value": "Monthly Sales Report"},
{"name": "year", "value": 2025}
]
```
**Data Source File Format (data.json):**
```json
{
"items": [
{"productName": "Widget A", "quantity": 100, "unitPrice": 25.50},
{"productName": "Widget B", "quantity": 50, "unitPrice": 45.00}
],
"summary": {
"totalItems": 150,
"totalValue": 4800.00
}
}
```
### Utility Commands
```bash
# List available server fonts (default)
muban fonts
# List all fonts including template-bundled ones
muban fonts --show-all
# List ICC color profiles (for PDF export)
muban icc-profiles
```
The `fonts` command shows server-installed fonts by default. Use `--show-all` to include fonts bundled with uploaded templates. When using `--show-all`, a "Source" column indicates whether each font comes from the server or a template.
### Admin Commands
```bash
# Verify template integrity
muban admin verify-integrity TEMPLATE_ID
# Regenerate integrity digest
muban admin regenerate-digest TEMPLATE_ID
# Regenerate all digests
muban admin regenerate-all-digests --yes
# Get server configuration
muban admin server-config
```
### Async Document Generation
```bash
# Submit a single async request
muban async submit -t TEMPLATE_ID -F PDF -p title="Report"
muban async submit -t TEMPLATE_ID -d params.json -c my-correlation-id
# Submit bulk requests from JSON file
muban async bulk requests.json
muban async bulk requests.json --batch-id batch-2026-01-15
# List async requests
muban async list
muban async list --status FAILED --since 1d
muban async list --template TEMPLATE_ID --format json
muban async list --format csv > async_jobs.csv # Export to CSV
# Get request details
muban async get REQUEST_ID
# Monitor workers and metrics (admin)
muban async workers
muban async metrics
muban async health
# View error log
muban async errors --since 24h
```
**Bulk Request File Format (requests.json):**
```json
[
{
"templateId": "abc123-uuid",
"format": "PDF",
"parameters": {"title": "Report 1"},
"correlationId": "req-001"
},
{
"templateId": "abc123-uuid",
"format": "XLSX",
"parameters": {"title": "Report 2"}
}
]
```
### Audit Commands
```bash
# View audit logs
muban audit logs
muban audit logs --severity HIGH --since 1d
muban audit logs --event-type LOGIN_FAILURE --format json
muban audit logs --format csv > audit_export.csv # Export to CSV
# Get audit statistics
muban audit statistics --since 7d
# View security events
muban audit security --since 24h
# Dashboard and monitoring
muban audit dashboard
muban audit threats
muban audit health
# List available event types
muban audit event-types
# Trigger cleanup
muban audit cleanup --yes
```
### User Management
```bash
# View your own profile
muban users me
# Update your profile
muban users update-me --email new@email.com --first-name John
# Change your password
muban users change-password
# List all users (admin only)
muban users list
muban users list --search "john" --role ROLE_ADMIN
muban users list --format csv > users.csv
# Get user details (admin only)
muban users get USER_ID
# Create a new user (admin only)
muban users create --username john --email john@example.com --role ROLE_USER
# Update a user (admin only)
muban users update USER_ID --email new@email.com
# Delete a user (admin only)
muban users delete USER_ID --yes
# Manage user roles (admin only)
muban users roles USER_ID --set ROLE_USER ROLE_MANAGER
muban users roles USER_ID --add ROLE_ADMIN
# Enable/disable user accounts (admin only)
muban users enable USER_ID
muban users disable USER_ID
# Set user password (admin only)
muban users set-password USER_ID
```
### Common Options
All commands support these options:
| Option | Short | Description |
|--------------|-------|------------------------------------------------|
| `--verbose` | `-v` | Enable verbose output |
| `--quiet` | `-q` | Suppress non-essential output |
| `--format` | `-f` | Output format: `table`, `json`, or `csv` |
| `--truncate` | | Max string length in table output (0=no limit) |
| `--help` | | Show help message |
**Output Format Examples:**
```bash
# Table output (default) - human-readable with colors
muban list
# JSON output - for programmatic parsing
muban list --format json
# CSV output - for Excel/spreadsheet integration
muban list --format csv > templates.csv
muban audit logs --format csv > audit.csv
# Template details with params/fields as unified CSV table
# (columns: Category, Name, Type, Value, Description)
muban get TEMPLATE_ID --params --fields --format csv > template.csv
# Template details as single JSON object with nested arrays
muban get TEMPLATE_ID --params --fields --format json
# Control truncation in table output (default: 50 chars)
muban list --truncate 80 # Longer strings
muban audit logs --truncate 0 # No truncation
```
**CSV Output Notes:**
- All CSV output uses raw numeric values (bytes, milliseconds) for data processing
- No pagination headers or decorative text in CSV output
- The `get` command with `--format csv` outputs a unified table with all template info, parameters, and fields in a single Excel-friendly format
## Graphical User Interface
Muban CLI includes an optional graphical user interface (GUI) for users who prefer a visual approach to template management and document generation.
### Launching the GUI
```bash
muban-gui
```
### GUI Features
The GUI provides a tabbed interface with the following sections:
#### **📦 Package Tab**
- Package JRXML template files with all dependencies (images, subreports)
- Visual asset discovery and preview
- Font bundling configuration
- Dry-run mode to preview package contents
- Auto-upload to server after packaging (when enabled in Settings)
#### **📄 Templates Tab**
- Browse all templates on the server with pagination
- Search and filter templates
- View template details, parameters, and fields
- Upload new templates (ZIP format)
- Download templates to local filesystem
- Delete templates with confirmation
#### **⚙️ Generate Tab**
- Select template and output format (PDF, XLSX, DOCX, RTF, HTML)
- Fill in template parameters with a dynamic form
- Load parameters from JSON file
- Provide JSON data sources
- Configure export options:
- **PDF options**: PDF/A compliance, embedded ICC profiles, password protection, permission settings
- **HTML options**: Resource embedding, single-file output, custom CSS
- Save generated documents to local filesystem
#### **🖥️ Server Info Tab**
- View server configuration and status
- List available fonts (server and template-bundled)
- List available ICC color profiles
- Check API connectivity and version
#### **⚙️ Settings Tab**
- Configure server URL
- Set authentication credentials
- Manage OAuth2 client credentials
- Set default author for template uploads
- Enable/disable auto-upload after packaging
- Test connection to server
### GUI Requirements
- Python 3.9+
- PyQt6 6.5.0 or later
- Configured Muban server (via CLI or Settings tab)
The GUI shares configuration with the CLI, so if you've already configured the CLI with `muban configure` and `muban login`, the GUI will use those settings automatically.
## CI/CD Integration
### GitHub Actions Example
```yaml
name: Deploy Report Template
on:
push:
branches: [main]
paths:
- 'templates/**'
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.9'
- name: Install Muban CLI
run: pip install muban-cli
- name: Deploy Template
env:
MUBAN_SERVER_URL: https://api.muban.me
MUBAN_CLIENT_ID: ${{ secrets.MUBAN_CLIENT_ID }}
MUBAN_CLIENT_SECRET: ${{ secrets.MUBAN_CLIENT_SECRET }}
run: |
muban login --client-credentials
cd templates
zip -r report.zip ./monthly_report/
muban push report.zip --name "Monthly Report" --author "CI/CD"
```
### GitLab CI Example
```yaml
deploy_template:
image: python:3.9-slim
stage: deploy
only:
changes:
- templates/**
script:
- pip install muban-cli
- muban login --client-credentials
- cd templates && zip -r report.zip ./monthly_report/
- muban push report.zip --name "Monthly Report" --author "GitLab CI"
variables:
MUBAN_SERVER_URL: https://api.muban.me
MUBAN_CLIENT_ID: $MUBAN_CLIENT_ID
MUBAN_CLIENT_SECRET: $MUBAN_CLIENT_SECRET
```
### Shell Script Example
```bash
#!/bin/bash
# deploy-template.sh
set -e
TEMPLATE_DIR="./my_jasper_project"
TEMPLATE_NAME="Monthly Sales Report"
AUTHOR="Deploy Script"
# Create ZIP archive
zip -r template.zip "$TEMPLATE_DIR"
# Upload to Muban
muban push template.zip \
--name "$TEMPLATE_NAME" \
--author "$AUTHOR" \
--metadata "Deployed from commit ${GIT_COMMIT:-unknown}"
# Cleanup
rm template.zip
echo "Template deployed successfully!"
```
## Error Handling
The CLI provides detailed error messages and appropriate exit codes:
| Exit Code | Meaning |
| --------- | ------- |
| 0 | Success |
| 1 | General error |
| 130 | Interrupted (Ctrl+C) |
### Detailed Error Messages
When API errors occur, the CLI displays:
- **Error code** - Machine-readable error identifier (e.g., `TEMPLATE_FILL_ERROR`)
- **Error message** - Human-readable description
- **Correlation ID** - Unique request identifier for support tickets
Example error output:
```text
✗ API request failed: [TEMPLATE_FILL_ERROR] Failed to fill template: Unable to load report (Correlation ID: 00154aac-eb74-4867-a009-c9762fa0e059)
```
The correlation ID can be provided to support teams for in-depth error analysis in server logs.
Correlation IDs are also logged to the application log file for batch operations.
### GUI Error Dialogs
In the graphical interface, API errors are displayed in a custom dialog that:
- Shows the full error message in a scrollable text area
- **Highlights the correlation ID** for easy identification
- Provides a **"Copy ID"** button to quickly copy the correlation ID to clipboard
- Provides a **"Copy All"** button to copy the entire error message
This makes it easy to create support tickets with the relevant debugging information.
### Retry Behavior
The CLI automatically retries requests on transient network errors:
| Status Code | Behavior |
| ----------- | -------- |
| 429 | Rate limited - retries honoring `Retry-After` header |
| 502 | Bad gateway - retries (typically load balancer issue) |
| 503 | Service unavailable - retries (temporary overload) |
| 504 | Gateway timeout - retries (may succeed on retry) |
| 500 | Internal error - **no retry** (application error, needs investigation) |
The retry mechanism respects the `Retry-After` header sent by the server for 429 responses, up to a maximum backoff of 2 minutes.
Configure retry behavior:
```bash
# Disable retries (fail fast)
muban configure --max-retries 0
# Set custom retry count (default: 3)
export MUBAN_MAX_RETRIES=5
```
### Common Errors
```bash
# Not configured
$ muban list
✗ Muban CLI is not configured.
Run 'muban configure' to set up your server, then 'muban login'.
# Not authenticated
$ muban list
✗ Not authenticated. Run 'muban login' to sign in.
# Template not found
$ muban get invalid-id
✗ Template not found: invalid-id
# Permission denied
$ muban delete some-template
✗ Permission denied. Manager role required.
```
## Development
### Running Tests
```bash
# Install dev dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Run with coverage
pytest --cov=muban_cli --cov-report=html
```
### Code Quality
```bash
# Format code
black muban_cli
isort muban_cli
# Type checking
mypy muban_cli
# Linting
flake8 muban_cli
```
### Project Structure
```text
muban-cli/
├── muban_cli/
│ ├── __init__.py # Package initialization, version info
│ ├── __main__.py # Entry point for python -m muban_cli
│ ├── cli.py # Main CLI entry point
│ ├── api.py # REST API client
│ ├── auth.py # Authentication (password + OAuth2)
│ ├── config.py # Configuration management
│ ├── utils.py # Utility functions (formatting, output)
│ ├── exceptions.py # Custom exceptions
│ ├── py.typed # PEP 561 marker
│ ├── commands/ # Command modules
│ │ ├── __init__.py # Common options decorator
│ │ ├── auth.py # login, logout, whoami, refresh
│ │ ├── templates.py # list, search, get, push, pull, delete
│ │ ├── generate.py # generate documents
│ │ ├── async_ops.py # async job management
│ │ ├── audit.py # audit logs and monitoring
│ │ ├── admin.py # admin operations
│ │ ├── users.py # user management
│ │ ├── resources.py # fonts, icc-profiles
│ │ └── settings.py # configure, config-clear
│ └── gui/ # Graphical User Interface (optional)
│ ├── __init__.py
│ ├── main.py # GUI entry point
│ ├── main_window.py
│ ├── tabs/ # Tab widgets
│ │ ├── package_tab.py
│ │ ├── templates_tab.py
│ │ ├── generate_tab.py
│ │ ├── server_info_tab.py
│ │ └── settings_tab.py
│ ├── dialogs/ # Dialog windows
│ └── resources/ # Icons and images
├── tests/ # Test suite
│ ├── conftest.py # Test fixtures
│ ├── test_api.py
│ ├── test_auth.py
│ ├── test_cli_simple.py
│ ├── test_commands.py
│ ├── test_config.py
│ ├── test_exceptions.py
│ └── test_utils.py
├── docs/ # Documentation
├── pyproject.toml # Project configuration
├── LICENSE # MIT License
└── README.md # This file
```
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Support
- Email: <contact@muban.me>
- Documentation: <https://muban.me/features.html>
## 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/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
| text/markdown | null | Muban Team <contact@muban.me> | null | Muban Team <contact@muban.me> | null | muban, jasperreports, document-generation, cli, pdf, reporting, templates | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: System Administrators",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
... | [] | null | null | >=3.9 | [] | [] | [] | [
"click>=8.0.0",
"requests>=2.25.0",
"urllib3>=1.26.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-mock>=3.10.0; extra == \"dev\"",
"pytest-qt>=4.2.0; extra == \"dev\"",
"responses>=0.23.0; extra == \"dev\"",
"black>=23.0.0; extra == \"dev\"",
"isort>=5.12.0; ... | [] | [] | [] | [
"Homepage, https://muban.me",
"Documentation, https://muban.me/features.html"
] | twine/6.2.0 CPython/3.13.12 | 2026-02-18T10:23:20.329988 | muban_cli-1.3.8.tar.gz | 158,608 | b0/98/f0d820394a9033b24e6dc420fd970ffd8f48b0b8813ed2ed6bb7514a405c/muban_cli-1.3.8.tar.gz | source | sdist | null | false | fe04fa3a771b7875cd544cc3c87bd420 | ed7262539491d33824446bf1ffec204b0bb8d02f1b099dce78cd873505f6c2c9 | b098f0d820394a9033b24e6dc420fd970ffd8f48b0b8813ed2ed6bb7514a405c | MIT | [
"LICENSE"
] | 248 |
2.4 | talentsavvy-improveteam | 0.37.98 | Scripts for data extraction scripts from software development systems | # TalentSavvy ImproveTeam
Scripts for data extraction scripts from software development systems
## Installation
Install the package using pip:
```bash
pip install talentsavvy-improveteam
```
That's it! The package is published on PyPI, so no special index URLs or authentication is required.
This will automatically install all required dependencies:
- paramiko
- pytz
- python-dateutil
- pandas
- requests
- urllib3
### Viewing Package Information
To view package information including installation location:
```bash
pip show talentsavvy-improveteam
```
This displays:
- Package metadata (version, author, etc.)
- Installation location (Location field)
- Required dependencies
- Entry points (available commands)
### Accessing This Documentation
The full README documentation is available in several ways:
1. **PyPI Website**: View the package page at https://pypi.org/project/talentsavvy-improveteam/
- The README content is displayed automatically on the package page
2. **Using pip**: The `pip show` command displays basic package information including location and dependencies
3. **Package Metadata**: The README is included in the package's metadata (as `long_description`)
4. **Installed Files**: After installation, the README can be found at:
```bash
<site-packages>/talentsavvy_improveteam-<version>.dist-info/metadata.json
```
Or view the raw README content:
```bash
python -c "import pkg_resources; print(pkg_resources.get_distribution('talentsavvy-improveteam').get_metadata('DESCRIPTION.rst'))"
```
## Configuration
The package includes a sample `config.json` file that contains the configuration template.
### Finding the Package Location
To locate where the package files are installed, use the following command to get the Location:
```
pip show talentsavvy-improveteam
```
The `config.json` file is installed at:
```
<site-packages>/common/config.json
```
Where `<site-packages>` is typically:
- **Windows**: `C:\Python<version>\Lib\site-packages\` (system-wide) or `C:\Users\<username>\AppData\Local\Programs\Python\Python<version>\Lib\site-packages\` (user installation)
- **Linux/macOS**: `/usr/local/lib/python<version>/site-packages/` (system-wide) or `~/.local/lib/python<version>/site-packages/` (user installation)
### Setup Instructions
1. **Update `config.json`** with your specific configuration values for each data source you plan to use.
2. Refer to each extraction script's documentation for the specific configuration keys it requires.
## Usage
After installing the package, you can run the data extraction scripts from the command line.
### Running Data Extraction Scripts
Each extraction script can be run with the following syntax:
```bash
extract_<source> -s <start_date>
```
Where `<source>` is one of:
- `jira` - Jira work item events
- `gitlab` - GitLab code events
- `github` - GitHub pull request events
- `github_actions` - GitHub Actions workflow events
- `jenkins` - Jenkins build events
- `azuredevops_boards` - Azure DevOps work item events
- `azuredevops_pipelines` - Azure DevOps pipeline events
- `azuredevops_repos` - Azure DevOps repository events
- `bitbucket_repos` - Bitbucket repository events
- `bitbucket_pipelines` - Bitbucket pipeline events
- `octopus` - Octopus Deploy deployment events
And `<start_date>` is optional and should be in `YYYY-MM-DD` format.
### Examples
**Extract Jira work items:**
```bash
extract_jira -s 2025-04-01
```
**Extract GitLab code events:**
```bash
extract_gitlab -s 2025-04-01
```
**Extract Jenkins builds:**
```bash
extract_jenkins -s 2025-04-01
```
If no start date is provided, the scripts will use the last checkpoint date (if available) or a default date.
### Output
The extracted data will be saved as CSV files in the directory specified by the `EXPORT_PATH` key in your `config.json` file (default: `./export` directory).
Each script maintains a checkpoint file to track the last extraction timestamp, allowing for incremental extractions on subsequent runs.
### SFTP Upload
After extraction, you can upload the CSV files to an SFTP server:
```bash
sftp_upload
```
This will upload all CSV files from the export directory to the configured SFTP server and delete them locally after successful upload.
| text/markdown | TalentSavvy.com | null | null | null | null | null | [
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Operating System :: OS Independent"
] | [] | null | null | >=3.7 | [] | [] | [] | [
"paramiko",
"pytz",
"python-dateutil",
"pandas",
"requests",
"urllib3"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.25 | 2026-02-18T10:22:23.280440 | talentsavvy_improveteam-0.37.98.tar.gz | 117,475 | 53/f8/0cb1570a20bc3b609b75dfd277723b7866a8b230514b03c7329d911fb4b2/talentsavvy_improveteam-0.37.98.tar.gz | source | sdist | null | false | d6c2bcf05497d4072a53d474f6ae2133 | b0f4d6e5be4b7e4893cb93dfafe7a960055de15c0bf611aad841fdcb47d69263 | 53f80cb1570a20bc3b609b75dfd277723b7866a8b230514b03c7329d911fb4b2 | null | [] | 271 |
2.4 | apflow | 0.18.1 | Agent workflow orchestration and execution platform | # apflow
<p align="center">
<img src="apflow-logo.svg" alt="apflow Logo" width="128" height="128" />
</p>
**Distributed Task Orchestration Framework**
apflow is a distributed task orchestration framework that scales from a single process to multi-node clusters. It provides a unified execution interface with 12+ built-in executors, A2A protocol support, and automatic leader election with failover.
Start standalone in 30 seconds. Scale to distributed clusters without code changes.
## Deployment Modes
### Standalone (Development and Small Workloads)
```bash
pip install apflow
```
Single process, DuckDB storage, zero configuration. Ideal for development, testing, and small-scale automation.
```python
from apflow.core.builders import TaskBuilder
from apflow import TaskManager, create_session
db = create_session()
task_manager = TaskManager(db)
result = await (
TaskBuilder(task_manager, "rest_executor")
.with_name("fetch_data")
.with_input("url", "https://api.example.com/data")
.with_input("method", "GET")
.execute()
)
```
### Distributed Cluster (Production)
```bash
pip install apflow[standard]
```
PostgreSQL-backed, leader/worker topology with automatic leader election, task leasing, and horizontal scaling. Same application code -- only the runtime environment changes.
```bash
# Leader node
APFLOW_CLUSTER_ENABLED=true \
APFLOW_DATABASE_URL=postgresql+asyncpg://user:pass@db:5432/apflow \
APFLOW_NODE_ROLE=auto \
apflow serve --port 8000
# Worker node (on additional machines)
APFLOW_CLUSTER_ENABLED=true \
APFLOW_DATABASE_URL=postgresql+asyncpg://user:pass@db:5432/apflow \
APFLOW_NODE_ROLE=worker \
apflow serve --port 8001
```
Add worker nodes at any time. The cluster auto-discovers them via the shared database.
## Installation Options
| Extra | Command | Includes |
|-------|---------|----------|
| Core | `pip install apflow` | Task orchestration, DuckDB storage, core executors |
| Standard | `pip install apflow[standard]` | Core + A2A server + CLI + CrewAI + LLM + tools |
| A2A Server | `pip install apflow[a2a]` | A2A Protocol server (HTTP/SSE/WebSocket) |
| CLI | `pip install apflow[cli]` | Command-line interface |
| PostgreSQL | `pip install apflow[postgres]` | PostgreSQL storage (required for distributed) |
| CrewAI | `pip install apflow[crewai]` | LLM-based agent crews |
| LLM | `pip install apflow[llm]` | Direct LLM via LiteLLM (100+ providers) |
| SSH | `pip install apflow[ssh]` | Remote command execution |
| Docker | `pip install apflow[docker]` | Containerized execution |
| gRPC | `pip install apflow[grpc]` | gRPC service calls |
| Email | `pip install apflow[email]` | Email sending (SMTP) |
| All | `pip install apflow[all]` | Everything |
## Built-in Executors
| Executor | Purpose | Extra |
|----------|---------|-------|
| RestExecutor | HTTP/REST API calls with auth and retry | core |
| CommandExecutor | Local shell command execution | core |
| SystemInfoExecutor | System information collection | core |
| ScrapeExecutor | Web page scraping | core |
| WebSocketExecutor | Bidirectional WebSocket communication | core |
| McpExecutor | Model Context Protocol tools and data sources | core |
| ApFlowApiExecutor | Inter-instance API calls for distributed execution | core |
| AggregateResultsExecutor | Aggregate results from multiple tasks | core |
| SshExecutor | Remote command execution via SSH | [ssh] |
| DockerExecutor | Containerized command execution | [docker] |
| GrpcExecutor | gRPC service calls | [grpc] |
| SendEmailExecutor | Send emails via SMTP or Resend API | [email] |
| CrewaiExecutor | LLM agent crews via CrewAI | [crewai] |
| BatchCrewaiExecutor | Atomic batch of multiple crews | [crewai] |
| LLMExecutor | Direct LLM interaction via LiteLLM | [llm] |
| GenerateExecutor | Natural language to task tree via LLM | [llm] |
## Architecture
```
+--------------------------+
| Client / CLI / API |
+------------+-------------+
|
+------------------+------------------+
| | |
+---------v--------+ +------v------+ +----------v--------+
| Leader Node | | Worker Node | | Worker Node |
| (auto-elected) | | | | |
| - Task placement | | - Execute | | - Execute |
| - Lease mgmt | | - Heartbeat| | - Heartbeat |
| - Execute | | | | |
+---------+--------+ +------+------+ +----------+--------+
| | |
+------------------+------------------+
|
+------------v-------------+
| PostgreSQL (shared) |
| - Task state |
| - Leader lease |
| - Node registry |
+--------------------------+
```
*Standalone mode uses the same architecture with a single node and DuckDB storage.*
## Documentation
- [Getting Started](docs/getting-started/quick-start.md) -- Up and running in 10 minutes
- [Distributed Cluster Guide](docs/guides/distributed-cluster.md) -- Multi-node deployment
- [Executor Selection Guide](docs/guides/executor-selection.md) -- Choose the right executor
- [API Reference](docs/api/python.md) -- Python API documentation
- [Architecture Overview](docs/architecture/overview.md) -- Design and internals
- [Protocol Specification](docs/protocol/index.md) -- A2A Protocol spec
Full documentation: [flow-docs.aipartnerup.com](https://flow-docs.aipartnerup.com)
## Contributing
Contributions are welcome. See [Contributing Guide](docs/development/contributing.md) for setup and guidelines.
## License
Apache-2.0
## Links
- **Documentation**: [flow-docs.aipartnerup.com](https://flow-docs.aipartnerup.com)
- **Website**: [aipartnerup.com](https://aipartnerup.com)
- **GitHub**: [aipartnerup/apflow](https://github.com/aipartnerup/apflow)
- **PyPI**: [apflow](https://pypi.org/project/apflow/)
| text/markdown | null | aipartnerup <tercel.yi@gmail.com> | null | null | Apache-2.0 | ai, agent, orchestration, workflow, task, crewai, a2a | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"pydantic[email]>=2.0.0",
"pydantic-settings>=2.0.0",
"sqlalchemy>=2.0.0",
"sqlalchemy-session-proxy>=0.1.0",
"alembic>=1.13.0",
"duckdb-engine>=0.10.0",
"pytz>=2024.1",
"fastapi>=0.115.0; extra == \"a2a\"",
"uvicorn[standard]>=0.29.0; extra == \"a2a\"",
"a2a-sdk[http-server]>=0.3.22; extra == \"a... | [] | [] | [] | [
"Homepage, https://aipartnerup.com",
"Source, https://github.com/aipartnerup/apflow"
] | twine/6.2.0 CPython/3.12.10 | 2026-02-18T10:22:22.359146 | apflow-0.18.1.tar.gz | 1,347,604 | 16/2a/7058de509435fe18d38b74f88a7a217b61532249b6a1668bd4170a7114ab/apflow-0.18.1.tar.gz | source | sdist | null | false | b853a2c1165fba03dcce04ee339f10d9 | 0deb99acf1b2b7ecdc7c0cc192457a9bdd92785a214e6e6ecf0a43112e6e45dd | 162a7058de509435fe18d38b74f88a7a217b61532249b6a1668bd4170a7114ab | null | [
"LICENSE"
] | 273 |
2.4 | datagouv_client | 0.2.4.dev3 | Wrapper for the data.gouv.fr API | 
# **datagouv-client**
[](https://circleci.com/gh/datagouv/datagouv_client)
[](https://opensource.org/licenses/MIT)
A Python wrapper for the data.gouv.fr API that allows you to interact easily with datasets and resources across all three platforms (production `www`, `demo`, and `dev`). Install it through [PyPI](https://pypi.org/project/datagouv-client/):
```bash
pip install datagouv-client
```
**Requirements:** Python >= 3.10
## 🚀 Use
### 📥 Quick Start
```python
from datagouv import Dataset, Resource, Topic
# Get a dataset and its resources
dataset = Dataset("5d13a8b6634f41070a43dff3")
print(f"Dataset: {dataset.title}")
print(f"Resources: {len(dataset.resources)}")
# Download a resource
resource = dataset.resources[0]
resource.download("my_file.csv")
# Get a topic and its elements
topic = Topic("68b6e6dbdac745f47d4ff6e0")
elements = topic.elements
datasets = topic.datasets
```
### 📊 Getting existing objects
If you only want to retrieve existing objects (aka you don't want to modify them on datagouv), here is what a workflow could look like:
```python
from datagouv import Dataset, Resource, Organization
dataset = Dataset("5d13a8b6634f41070a43dff3") # you can find a dataset's id in the `Informations` tab of its landing page
# you can now access a bunch of info about the dataset
print(dataset.title)
print(dataset.description)
print(dataset.created_at)
print(dataset.organization) # this is an instance of Organization
print(dataset) # this displays all the attributes of the dataset as a dict
# and of course its resources, which are all Resource instances
for res in dataset.resources:
print(res.title)
print(res.url) # this is the download URL of the resource
print(res.id) # the id of the resource itself
print(res.dataset_id) # the id of the dataset the resource belongs to
print(res) # this displays all the attributes of the resource as a dict
# if you are only interested in a specific resource
resource = Resource("f868cca6-8da1-4369-a78d-47463f19a9a3") # you can find a resource's id in its `Métadonnées` tab
print(resource)
# you can also access a dataset from one of its resources
d = resource.dataset # this returns an instance of Dataset
# you can also download a resource locally (**Note:** if it doesn't exist, parent path will be created)
resource.download("./file.csv") # this saves the resource in your working directory as "file.csv"
# and a subset or all resources of a dataset (**Note:** if it doesn't exist, parent path will be created)
# the files are named `resource_id.format` (for instance f868cca6-8da1-4369-a78d-47463f19a9a3.csv)
d.download_resources(
folder="data", # if not specified, saves them into your working directory
resources_types=["main", "documentation"], # default is only main resources
)
organization = Organization("646b7187b50b2a93b1ae3d45") # you can find an organization's id in the `Informations` tab of its landing page, in "Informations techniques"
# you can loop through the organization's datasets, which are Dataset instances
for dat in organization.datasets:
print(f"{dat.title} has {len(dat.resources)} resources")
```
> **Note:** If you encounter errors during API calls, the client will raise appropriate exceptions (e.g., `PermissionError` for authentication issues, `httpx.HTTPError` for API errors).
> **Note:** If you want to get objects from demo or dev, you must use a client:
```python
from datagouv import Client, Dataset, Resource
dataset = Dataset("5d13a8b6634f41070a43dff3", _client=Client("demo"))
```
You can also access objects' metrics (views, downloads) with the `get_monthly_traffic_metrics` function:
```python
for month_metrics in Dataset("5d13a8b6634f41070a43dff3").get_monthly_traffic_metrics(
start_month="2025-01", # optional, goes back as far as possible if not set
end_month="2025-06", # optional, until today if not set
):
print(month_metrics)
```
The metrics differ depending on the object:
- for datasets:
```json
{
"__id": 43110395,
"dataset_id": "6789251f3a805425afee55e6",
"metric_month": "2025-01",
"monthly_visit": 233,
"monthly_download_resource": 3
}
```
- for resources:
```json
{
"__id": 58728461,
"resource_id": "5ffa8553-0e8f-4622-add9-5c0b593ca1f8",
"dataset_id": "5c4ae55a634f4117716d5656",
"metric_month": "2025-04",
"monthly_download_resource": 5669
}
```
- for organizations:
```json
{
"__id": 7,
"organization_id": "646b7187b50b2a93b1ae3d45",
"metric_month": "2023-07",
"monthly_visit_dataset": 27196,
"monthly_download_resource": 1085933,
"monthly_visit_reuse": 123,
"monthly_visit_dataservice": 456
}
```
### 🛠️ Interacting with objects online
If you want to modify objects on the datagouv platforms, you will need to create an authenticated client:
```python
from datagouv import Client
client = Client(
environment="www", # here you can set which platform the client will interact with, default is production
api_key="MY_SECRET_API_KEY", # your API key, that grants your rights on the platform
)
```
> **Note:** You can find your API key on https://www.data.gouv.fr/fr/admin/me/ (don't forget to change the prefix to get the key from the right environment).
Once your client is set up, you can instantiate datasets and resources from it. Of course, **you will only be allowed to modify objects according to your rights** (so objects created by you or an organization you are part of):
```python
dataset = client.dataset("5d13a8b6634f41070a43dff3")
# this is also a Dataset instance, with all the same attributes as above, but since you're authenticated, you have access to new methods
dataset.update({"title": "A brand new title"}) # update the dataset online with the payload you give, and also update the attributes of the object
print(dataset.title) # -> "A brand new title"
dataset.delete() # delete the dataset, use with caution!
# you can also modify the extras
dataset.update_extras(payload)
dataset.delete_extras(payload)
# the methods are the same for resources
for idx, res in enumerate(dataset.resources):
res.update({"title": f"Resource n°{idx + 1}"})
print(res.title) # -> "Resource n°X"
# delete every third resource
if idx % 3 == 0:
res.delete()
```
With an authenticated client, you are also allowed to create datasets and resources on the environment you specified:
```python
dataset = client.dataset().create(
{
"title": "New dataset",
"description": "A description is required",
"organization": "646b7187b50b2a93b1ae3d45", # the organization that will own the dataset
},
) # this creates a dataset with the values you specified, and instantiates a Dataset
dataset.update({"tags": ["environment", "water"]})
# alternatively you can create a dataset from an organization, and it will be attached to it
organization = client.organization("646b7187b50b2a93b1ae3d45")
dataset = organization.create_dataset(
{
"title": "New dataset",
"description": "A description is a required",
}
)
```
There are two types of resources on datagouv:
- `static`: a file is uploaded directly on the platform
- `remote`: reference the URL of a file that is stored somewhere else on the internet
You have two options to create a resource (of any type):
- from the client itself, by specifying the id of the dataset you want to include it into (you must have the rights on the dataset):
```python
# to create a static resource from a file
resource = client.resource().create_static(
file_to_upload="path/to/your/file.txt",
payload={"title": "New static resource"},
dataset_id="5d13a8b6634f41070a43dff3",
) # this creates a static resource with the values you specified, and instantiates a Resource
# to create a remote resource from an url
resource = client.resource().create_remote(
payload={"url": "http://example.com/file.txt", "title": "New remote resource"},
dataset_id="5d13a8b6634f41070a43dff3",
) # this creates a remote resource with the values you specified, and instantiates a Resource
```
- from the dataset you want to include it into (you must have the rights on the dataset), in which case you don't have to specify the `dataset_id`:
```python
dataset = client.dataset("5d13a8b6634f41070a43dff3")
# to create a static resource from a file
resource = dataset.create_static(
file_to_upload="path/to/your/file.txt",
payload={"title": "New static resource"},
) # this creates a static resource with the values you specified, and instantiates a Resource
# to create a remote resource from an url
resource = dataset.create_remote(
payload={"url": "http://example.com/file.txt", "title": "New remote resource"},
) # this creates a remote resource with the values you specified, and instantiates a Resource
# to update the file of a static resource
resource.update({"title": "New title"}, file_to_upload="path/to/your/new_file.txt")
```
> **Note:** If you are not planning to use an object's attributes, you may prevent the initial API call using `fetch=False`, in order not to unnecessarily ping the API.
```python
dataset = client.dataset("5d13a8b6634f41070a43dff3", fetch=False)
print(dataset.title) # -> this will fail because the attributes are not set from the initial call
# but you can update the object as usual
dataset.update({"title": "New title"})
print(dataset.title) # -> "New title" because the attributes are set from the response
```
### ⚡ Advanced features
Many datagouv endpoints are paginated, which can make it tedious to retrieve all objects. An instance of `Client` has a method to create an iterator from any endpoint that returns paginated data:
```python
for obj in client.get_all_from_api_query(
"api/1/datasets/?organization=534fff81a3a7292c64a77e5c", # get all datasets from a specific organization
mask="data{id,title,resources{id,title}}", # you can apply a mask to retrieve only specific fields of the objects
cast_as=Dataset, # you can get the results as objects to manipulate them more easily
):
print(f"Dataset {obj['title']} has {len(obj['resources'])} resources") # if cast_as is not used, otherwise `obj.id` and `obj.resources`
```
You can also check if resources have been updated more recently than others:
```python
# Check if any resource in a dataset has been updated more recently than a specific resource
resource = Resource("f868cca6-8da1-4369-a78d-47463f19a9a3")
has_newer_updates = resource.check_if_more_recent_update("5d13a8b6634f41070a43dff3")
```
## 🤝 Contribution
Contributions and feedback are welcome! Main guidelines:
- as few API calls as possible (use responses to create/update objects)
- build on the existing
Remember to format, lint, and sort imports with [Ruff](https://docs.astral.sh/ruff/) before committing (checks will remind you anyway):
```bash
pip install .[dev]
ruff check --fix .
ruff format .
```
### 🏷️ Release
The release process uses the [`tag_version.sh`](tag_version.sh) script to create git tags and update [CHANGELOG.md](CHANGELOG.md) and [pyproject.toml](pyproject.toml) automatically.
**Prerequisites**: [GitHub CLI](https://cli.github.com/) (`gh`) must be installed and authenticated, and you must be on the main branch with a clean working directory.
```bash
# Create a new release
./tag_version.sh <version>
# Example
./tag_version.sh 2.5.0
# Dry run to see what would happen
./tag_version.sh 2.5.0 --dry-run
```
The script automatically:
- Updates the version in `pyproject.toml`
- Extracts commits since the last tag and formats them for `CHANGELOG.md`
- Identifies breaking changes (commits with `!:` in the subject)
- Creates a git tag and pushes it to the remote repository
- Creates a GitHub release with the changelog content
| text/markdown | null | Etalab <opendatateam@data.gouv.fr> | null | null | null | api, wrapper, datagouv | [] | [] | null | null | <3.14,>=3.10 | [] | [] | [] | [
"httpx<1,>=0.28.1",
"tenacity<10,>=9.0.0",
"httpx<1,>=0.28.1; extra == \"dev\"",
"pytest-httpx<1,>=0.35.0; extra == \"dev\"",
"ruff>=0.11.2; extra == \"dev\""
] | [] | [] | [] | [
"Source, https://github.com/datagouv/datagouv_client"
] | uv/0.9.30 {"installer":{"name":"uv","version":"0.9.30","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Debian GNU/Linux","version":"12","id":"bookworm","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true} | 2026-02-18T10:20:48.909119 | datagouv_client-0.2.4.dev3-py3-none-any.whl | 15,599 | 02/f7/e52c420738ee79bd9158df827a01a19af54ccae8249c09a10cb053424106/datagouv_client-0.2.4.dev3-py3-none-any.whl | py3 | bdist_wheel | null | false | 03a8c46cdf4bf359376082afad77abb4 | 7518e00f494c95a8848726f6f064e3451039be0a17cb6e00a28c0d81429ae407 | 02f7e52c420738ee79bd9158df827a01a19af54ccae8249c09a10cb053424106 | MIT | [
"LICENSE"
] | 0 |
2.4 | loggerizer | 1.1.0 | A flexible logging framework with JSON, file, and SMTP logging | # Loggerizer
A simple, powerful wrapper for Python's built-in logging module.
[](https://pypi.org/project/loggerizer/)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
## Installation
```bash
pip install loggerizer
```
## Quick Start
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.console()
logger.info("Hello, World!")
```
## Logger Types
### Console Logger
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.console()
logger.info("Human-readable console output")
```
### Colored Console Logger
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.console(colorize=True)
logger.debug("Dim metadata, bold cyan level")
logger.info("Bold green level name")
logger.warning("Bold yellow level name")
logger.error("Red level + red message")
logger.critical("Bright red level + red message")
```
Color scheme:
- **Level name**: bold + level color, padded to fixed width
- **Message**: default terminal color (colored red for ERROR/CRITICAL)
- **Exceptions**: colored tracebacks for ERROR/CRITICAL
- **Metadata** (timestamp, logger name, etc.): dim gray
- **Separator**: dim `│`
Colors are automatically disabled when output is piped or redirected. Works on Linux, macOS, and Windows.
### Colored Console Logger (Builder)
```python
from loggerizer import LoggerBuilder, handlers, LogLevel
from loggerizer.formatters import ColorFormatter
logger = (
LoggerBuilder()
.name("my_app")
.level(LogLevel.DEBUG)
.formatter(ColorFormatter(flat=True))
.handler(handlers.stream())
.build()
)
```
### Custom Color Mapping
```python
from loggerizer.formatters import ColorFormatter
formatter = ColorFormatter(
flat=True,
colors={"DEBUG": "\033[35m"}, # magenta for DEBUG
)
```
### Console JSON Logger
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.console_json()
logger.info("Structured JSON output")
```
### File Logger
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.file("app.log")
logger.info("Logging to file")
```
### JSON File Logger
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.file_json("app.json")
logger.info("JSON logging to file")
```
### Rotating Logger (by size)
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.rotating(
"app.log",
max_bytes=10_000_000, # 10MB
backup_count=5
)
logger.info("Size-based rotation")
```
### Timed Rotating Logger
```python
from loggerizer import LoggerFactory, RotateWhen
logger = LoggerFactory.timed_rotating(
"app.log",
when=RotateWhen.MIDNIGHT,
backup_count=7
)
logger.info("Time-based rotation")
```
### Email Logger
```python
from loggerizer import LoggerFactory, SMTPConfig
config = SMTPConfig(
host=("smtp.example.com", 587),
from_address="alerts@example.com",
to_address=["admin@example.com"],
subject="[ALERT] Application Error",
)
logger = LoggerFactory.email(config)
logger.error("Critical error occurred!")
```
### Null Logger
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.null()
logger.info("This message is discarded")
```
## Custom Logger (Builder Pattern)
```python
from loggerizer import LoggerBuilder, handlers, LogLevel, LogField, DefaultFormatter
logger = (
LoggerBuilder()
.name("my_app")
.level(LogLevel.DEBUG)
.formatter(DefaultFormatter(
fields=[LogField.ASC_TIME, LogField.LEVEL_NAME, LogField.MESSAGE, LogField.MODULE],
flat=True
))
.handler(handlers.stream())
.handler(handlers.file("app.log"))
.build()
)
logger.debug("Debug message")
logger.info("Info message")
logger.error("Error message")
```
## Adding Extra Data
```python
from loggerizer import LoggerFactory
logger = LoggerFactory.console_json()
logger.info("User action", extra={"user_id": 123, "action": "login", "ip": "192.168.1.1"})
```
## Custom Fields
```python
from loggerizer import LoggerFactory, LogField
logger = LoggerFactory.console(
fields=[
LogField.ASC_TIME,
LogField.LEVEL_NAME,
LogField.MESSAGE,
LogField.MODULE,
LogField.FUNC_NAME,
LogField.LINE_NO,
]
)
logger.info("With extra context")
```
## Available Log Fields
| Field | Description |
|-------|-------------|
| `ASC_TIME` | Human-readable timestamp |
| `LEVEL_NAME` | Log level (DEBUG, INFO, etc.) |
| `MESSAGE` | Log message |
| `NAME` | Logger name |
| `MODULE` | Module name |
| `FUNC_NAME` | Function name |
| `LINE_NO` | Line number |
| `FILE_NAME` | File name |
| `PATH_NAME` | Full file path |
| `PROCESS` | Process ID |
| `THREAD` | Thread ID |
| `EXCEPTION` | Exception info |
## Formatters
| Formatter | Description |
|-----------|-------------|
| `DefaultFormatter` | Human-readable pipe-separated output |
| `ColorFormatter` | ANSI-colored console output with per-segment styling |
| `JsonFormatter` | Structured JSON output |
## Handlers
```python
from loggerizer import handlers
handlers.stream() # Console output
handlers.file("app.log") # File output
handlers.rotating("app.log") # Size-based rotation
handlers.timed_rotating("app.log") # Time-based rotation
handlers.smtp(config) # Email alerts
handlers.null() # Discard logs
```
## License
MIT
| text/markdown | null | Ayman Kastali <aymankastali.backend@gmail.com> | null | null | null | logging, logger, json, structured-logging | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Topic :: Sys... | [] | null | null | >=3.11 | [] | [] | [] | [
"pytest==9.0.2; extra == \"dev\"",
"pylint==4.0.4; extra == \"dev\"",
"ruff==0.15.0; extra == \"dev\"",
"twine==6.2.0; extra == \"dev\"",
"pre-commit==4.0.1; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/AymanKastali/loggerizer",
"Repository, https://github.com/AymanKastali/loggerizer",
"Documentation, https://github.com/AymanKastali/loggerizer#readme",
"Issues, https://github.com/AymanKastali/loggerizer/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:18:19.318699 | loggerizer-1.1.0.tar.gz | 14,003 | f2/5c/6508a77915fda1d904fdaeb9e9c0104a708ea2f407b1ee612446ef10c322/loggerizer-1.1.0.tar.gz | source | sdist | null | false | 0a6df48fb3d57dc381d144f50cb1da3a | 3ed0009673231cd8f697bde7887f00f917e3d89706e1e03ad746dd9d1f1889b3 | f25c6508a77915fda1d904fdaeb9e9c0104a708ea2f407b1ee612446ef10c322 | MIT | [] | 266 |
2.4 | redash-mcp | 0.2.0 | Model Context Protocol (MCP) server for Redash - manage queries, dashboards, and visualizations | # redash-mcp
Model Context Protocol (MCP) server for [Redash](https://redash.io/) - manage queries, dashboards, and visualizations through AI assistants like Claude.
## Features
- **7 tools, 30 actions** - compressed for minimal context usage
- Full query management (list, search, create, update, archive, delete, run, adhoc, export, schedule)
- Dashboard management (list, get, create, publish, delete)
- Widget management with positioning (add, move, delete)
- Alert management (list, get, create, update, delete)
- Visualization creation (pie, line, bar, counter charts)
- Data source listing
## Installation
```bash
pip install redash-mcp
```
Or with [uvx](https://github.com/astral-sh/uv):
```bash
uvx redash-mcp
```
## Configuration
### Environment Variables
| Variable | Required | Description |
|----------|----------|-------------|
| `REDASH_URL` | Yes | Your Redash instance URL (e.g., `https://redash.example.com`) |
| `REDASH_API_KEY` | Yes | Your Redash API key |
| `REDASH_TIMEOUT` | No | Request timeout in seconds (default: 30) |
### Claude Code
Add to `~/.claude.json` (user-level config):
```json
{
"mcpServers": {
"redash": {
"type": "stdio",
"command": "uvx",
"args": ["redash-mcp"],
"env": {
"REDASH_URL": "https://your-redash-instance.com",
"REDASH_API_KEY": "your-api-key"
}
}
}
}
```
### Claude Desktop
Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"redash": {
"command": "uvx",
"args": ["redash-mcp"],
"env": {
"REDASH_URL": "https://your-redash-instance.com",
"REDASH_API_KEY": "your-api-key"
}
}
}
}
```
Or if installed via pip:
```json
{
"mcpServers": {
"redash": {
"command": "redash-mcp",
"env": {
"REDASH_URL": "https://your-redash-instance.com",
"REDASH_API_KEY": "your-api-key"
}
}
}
}
```
## Tools
### `redash_data_sources`
List all available data sources.
### `redash_query`
Manage Redash queries.
| Action | Parameters | Description |
|--------|------------|-------------|
| `list` | `page` | List all queries (paginated) |
| `search` | `q` | Search queries by name |
| `get` | `id` | Get query details |
| `create` | `name`, `query`, `data_source_id` | Create new query |
| `update` | `id`, `query?`, `name?` | Update existing query |
| `archive` | `id` | Archive (soft-delete) query |
| `delete` | `id` | Permanently delete query |
| `run` | `id`, `timeout?` | Execute query and wait for results |
| `adhoc` | `query`, `data_source_id` | Execute SQL without saving |
| `export` | `id`, `path` | Export query results to file (.csv or .json) |
| `schedule` | `id`, `interval`, `until?` | Schedule query execution (interval in seconds) |
### `redash_dashboard`
Manage Redash dashboards.
| Action | Parameters | Description |
|--------|------------|-------------|
| `list` | `page` | List all dashboards |
| `get` | `id` | Get dashboard with widgets |
| `create` | `name` | Create new dashboard |
| `publish` | `id` | Publish dashboard (remove draft) |
| `delete` | `id` | Delete dashboard |
### `redash_widget`
Manage dashboard widgets.
| Action | Parameters | Description |
|--------|------------|-------------|
| `add` | `dashboard_id`, `viz_id`, `col?`, `row?`, `sizeX?`, `sizeY?` | Add visualization with optional position |
| `move` | `id`, `col?`, `row?`, `sizeX?`, `sizeY?` | Reposition/resize a widget |
| `delete` | `id` | Remove widget from dashboard |
### `redash_alert`
Manage query alerts.
| Action | Parameters | Description |
|--------|------------|-------------|
| `list` | | List all alerts |
| `get` | `id` | Get alert details |
| `create` | `query_id`, `name`, `column`, `op`, `value`, `rearm?` | Create alert on query result |
| `update` | `id`, `name?`, `rearm?` | Update alert settings |
| `delete` | `id` | Delete alert |
### `redash_viz`
Create visualizations.
| Type | Parameters | Description |
|------|------------|-------------|
| `pie` | `query_id`, `name`, `x`, `y` | Pie chart |
| `line` | `query_id`, `name`, `x`, `y`, `datetime?` | Line chart |
| `bar` | `query_id`, `name`, `x`, `y`, `stacked?` | Bar chart |
| `counter` | `query_id`, `name`, `x`, `suffix?` | Counter/KPI |
**Note:** For multiple Y columns, pass comma-separated values: `y="count,total,avg"`
## Examples
### Create a dashboard with visualizations
```
1. redash_data_sources() → get data_source_id
2. redash_query(action="create", name="Daily Stats", query="SELECT ...", data_source_id=1)
3. redash_viz(type="line", query_id=123, name="Trend", x="date", y="count")
4. redash_dashboard(action="create", name="My Dashboard")
5. redash_widget(action="add", dashboard_id=456, viz_id=789)
6. redash_dashboard(action="publish", id=456)
```
### Run ad-hoc query
```
redash_query(action="adhoc", query="SELECT COUNT(*) FROM users", data_source_id=1)
```
### Export query results
```
redash_query(action="export", id=123, path="/tmp/results.csv")
redash_query(action="export", id=123, path="/tmp/results.json")
```
### Search and update query
```
redash_query(action="search", q="daily")
redash_query(action="update", id=123, query="SELECT ... WHERE date > NOW() - INTERVAL '7 days'")
```
## Python Library Usage
You can also use redash-mcp as a Python library:
```python
import os
os.environ["REDASH_URL"] = "https://your-redash.com"
os.environ["REDASH_API_KEY"] = "your-key"
from redash_mcp import (
list_queries, create_query, run_query,
create_dashboard, publish_dashboard,
line, bar, pie, counter,
add_widget
)
# Create query
q = create_query("My Query", "SELECT * FROM events", data_source_id=1)
# Create visualization
viz = line(q["id"], "Events Trend", x="date", y=["count"])
# Create dashboard and add widget
d = create_dashboard("My Dashboard")
add_widget(d["id"], viz["id"])
publish_dashboard(d["id"])
```
## Why redash-mcp?
- **Context efficient** - Only 7 tools (~500 tokens) with 30 actions
- **Full-featured** - Queries, dashboards, widgets, and visualizations
- **Production ready** - Proper error handling and timeouts
- **Dual use** - Works as MCP server and Python library
## License
MIT
| text/markdown | null | Shivansh Singh <wiseeldrich2004@gmail.com> | null | null | null | ai, claude, dashboard, mcp, model-context-protocol, redash, visualization | [
"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"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"requests>=2.28.0"
] | [] | [] | [] | [
"Homepage, https://github.com/wise-toddler/redash-mcp",
"Repository, https://github.com/wise-toddler/redash-mcp",
"Issues, https://github.com/wise-toddler/redash-mcp/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:18:04.770423 | redash_mcp-0.2.0.tar.gz | 8,781 | 65/b6/f837875a0bc92a458190761a7b4beaa5a5e2cb4c03270ffb48b6398d5049/redash_mcp-0.2.0.tar.gz | source | sdist | null | false | 0989fa2d1afc2ebcbb568b3b757fd631 | 15c2da26dcca1828b05f5f9ef11d5fa26cc9e9e2607d9ac08a22486e07fcd916 | 65b6f837875a0bc92a458190761a7b4beaa5a5e2cb4c03270ffb48b6398d5049 | MIT | [
"LICENSE"
] | 282 |
2.4 | gcl-looper | 1.2.0 | Looper is a daemonizer library, it can help you with lifecycle of your daemon. | **GenesisCoreLibs Looper Documentation**
==========================
**Overview**
------------
GCL Looper is a Python library designed to create daemon-like services that can run indefinitely, performing tasks at regular intervals or on demand.
**Usage Examples**
-----------------
### Basic Service
- Iterate infinitely
- There should be at least 5 seconds between start of previous and next iteration (`iter_min_period`)
- pause for 1 second between iterations (`iter_pause`)
```python
from gcl_looper.services import basic
class MyService(basic.BasicService):
def __init__(self, iter_min_period=5, iter_pause=1):
super(MyService, self).__init__(iter_min_period, iter_pause)
def _iteration(self):
print("Iteration", self._iteration_number)
service = MyService()
service.start()
```
### Finite Service without any pauses in-between
```python
from gcl_looper.services import basic
class MyFiniteService(basic.BasicService):
def __init__(self, iter_min_period=0, iter_pause=0):
super(MyFiniteService, self).__init__(iter_min_period, iter_pause)
self.countdown = 3
def _iteration(self):
if self.countdown > 1:
self.countdown -= 1
else:
self.stop()
service = MyFiniteService()
service.start()
```
### API service with database (restalchemy)
```python
from gcl_looper.services import bjoern_service
from gcl_looper.services import hub
from oslo_config import cfg
from restalchemy.storage.sql import engines
from restalchemy.common import config_opts as db_config_opts
from MY_PACKAGE.user_api import app
api_cli_opts = [
cfg.StrOpt(
"bind-host", default="127.0.0.1", help="The host IP to bind to"
),
cfg.IntOpt("bind-port", default=8080, help="The port to bind to"),
cfg.IntOpt(
"workers", default=1, help="How many http servers should be started"
),
]
DOMAIN = "user_api"
CONF = cfg.CONF
CONF.register_cli_opts(api_cli_opts, DOMAIN)
db_config_opts.register_posgresql_db_opts(conf=CONF)
def main():
serv_hub = hub.ProcessHubService()
for _ in range(CONF[DOMAIN].workers):
service = bjoern_service.BjoernService(
wsgi_app=app.build_wsgi_application(),
host=CONF[DOMAIN].bind_host,
port=CONF[DOMAIN].bind_port,
bjoern_kwargs=dict(reuse_port=True),
)
service.add_setup(
lambda: engines.engine_factory.configure_postgresql_factory(
conf=CONF
)
)
serv_hub.add_service(service)
serv_hub.start()
if __name__ == "__main__":
main()
```
**Public interface:**
-----------------------------
* **`start()`**: Starts the service.
* **`stop()`**: Stop the service.
* **`_loop_iteration()`**: Performs one iteration of the service loop.
**Implement these methods to get usable service:**
---------------------------
* **`_iteration()`**: This method must be implemented by subclasses to perform the actual work at each iteration.
### Process Hub service
Process Hub allows running multiple services in separate processes. It's useful when you want to run multiple instances of a service (e.g., multiple API workers) or different services that should be isolated.
**Security Feature: Privilege Downgrade**
When using `ProcessHubService`, you can set `__mp_downgrade_user__` on a child service to automatically downgrade process privileges after the fork. This is a security best practice to minimize attack surface - start as root (if needed to bind to privileged ports), then downgrade to an unprivileged user.
* **`__mp_downgrade_user__`**: Class attribute set to a username (e.g., `"nobody"`). When set, the child process will downgrade to this user after forking. Default is `None` (no downgrade).
```python
from gcl_looper.services import hub
from gcl_looper.services import bjoern_service
serv_hub = hub.ProcessHubService()
# BjoernService has __mp_downgrade_user__ = "nobody" by default
for _ in range(4): # 4 workers
service = bjoern_service.BjoernService(
wsgi_app=my_app,
host="0.0.0.0",
port=80, # Privileged port, needs root to bind
bjoern_kwargs=dict(reuse_port=True),
)
serv_hub.add_service(service)
serv_hub.start()
# Each worker starts as root to bind port 80, then downgrades to 'nobody'
```
**Note:** This feature only works on Linux and requires the process to start as root. The target user must exist on the system.
**Manual Privilege Downgrade**
You can also manually downgrade privileges using the utility function:
```python
from gcl_looper import utils
# Downgrade to 'nobody' user
utils.downgrade_user_group_privileges("nobody")
```
### Launchpad Service
Launchpad service is a service that can run multiple services and execute them sequentially. It's convenient when you have multiple services that need to be run in a specific order or the services aren't heavy and you don't want to use multiprocessing. Also it simplifies the configuration of the services.
**Basic usage:**
```python
from gcl_looper.services import launchpad
services = [
MyService(),
MyFiniteService(),
]
service = launchpad.LaunchpadService(services)
service.start()
```
The most important part in the launchpad service is its configuration. In the configuration you specify how to run inner services, how to configure them and how to initialize them.
**Configuration options:**
* **`services`**: List of services to run. Each service can be specified as a string in the format `module.path:ServiceName::count` where `count` is optional and defaults to 1.
* **`common_registrator_opts`**: Common options for all services. These options are passed to the service constructor.
* **`common_initializer`**: Common initializer for all services. This initializer is called after the service is created and before it is started.
* **`iter_min_period`**: Minimum period between iterations of the service loop.
* **`iter_pause`**: Pause between iterations of the service loop.
**Example:**
```ini
[DEFAULT]
verbose = True
debug = True
[launchpad]
services =
my_package.service_foo:FooService,
my_package.service_bar:BarService,
my_package.service_baz:BazService
common_registrator_opts = my_package.service_common:common_opts
common_initializer = my_package.service_common:common_init
[my_package.service_foo:FooService]
name = foo
[my_package.service_bar:BarService]
name = bar
project_id = 123
[my_package.service_baz:BazService]
param1 = value1
param2 = value2
```
**Example with multiple instances of the same service:**
```ini
[DEFAULT]
verbose = True
debug = True
[launchpad]
services =
my_package.service_foo:FooService,
my_package.service_bar:BarService::2
[my_package.service_foo:FooService]
name = foo
[my_package.service_bar:BarService::0]
name = bar0
project_id = 123
[my_package.service_bar:BarService::1]
name = bar1
project_id = 456
```
| text/markdown | Genesis Corporation | mail@gmelikov.ru | null | null | null | null | [
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.10",
"Programming Langua... | [] | https://github.com/infraguys/gcl_looper | null | null | [] | [] | [] | [
"pbr<5.8.1,>=1.10.0",
"setuptools<76.0.0,>=75.3.0",
"oslo.config<10.0.0,>=3.22.2",
"importlib-metadata<7.0.0,>=6.8.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:17:29.341402 | gcl_looper-1.2.0.tar.gz | 23,371 | d5/15/59571bac751fb862e4923613374b67d87df40bd89e619b2f85106a46314e/gcl_looper-1.2.0.tar.gz | source | sdist | null | false | 67cb8abbcbab196a7cfef8a3a7befde5 | 2e56b3ec84e0a1824bc5e627f822cca28e3bee257ef618a52791801810d5ae99 | d51559571bac751fb862e4923613374b67d87df40bd89e619b2f85106a46314e | null | [
"LICENSE"
] | 839 |
2.1 | cryptbackup | 1.0.6 | Backup incremental AES-256, compression Zstandard, destinations multiples (USB, NAS, disque externe) | # 🔐 CryptBackup — Système de backup incrémental intelligent
<div align="center">
**Sauvegarde automatique avec chiffrement AES-256, compression Zstandard et détection en temps réel**
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/stephdeve/cryptbackup)
[](https://pypi.org/project/cryptbackup/)
[](https://pypi.org/project/cryptbackup/)
</div>
---
## Table des matières
- [Fonctionnalités](#-fonctionnalités)
- [Prérequis](#-prérequis)
- [Installation rapide](#-installation-rapide)
- [Initialisation](#-initialisation)
- [Utilisation](#-utilisation)
- [Configurer les sources et destinations](#configurer-les-sources-et-destinations)
- [Lancer un backup](#lancer-un-backup)
- [Statut et historique](#statut-et-historique)
- [Restaurations](#restaurations)
- [Nettoyage (rétention)](#nettoyage-rétention)
- [Destinations supportées](#-destinations-supportées)
- [Configuration avancée](#-configuration-avancée)
- [Comment ça marche](#-comment-ça-marche)
- [Sécurité](#-sécurité)
- [Dépannage](#-dépannage)
- [Roadmap](#-roadmap)
- [Contribution](#-contribution)
- [Licence et auteur](#-licence-et-auteur)
- [Remerciements](#-remerciements)
---
## Fonctionnalités
- Backup incrémental : sauvegarde uniquement les fichiers modifiés depuis la dernière version
- Chiffrement : AES-256-GCM (authentifié)
- Compression : Zstandard (zstd)
- Surveillance en temps réel (watch) / intervalle configurable
- Destinations multiples : PC local, disque externe, NAS, clé USB — jusqu'à 3 destinations simultanées
- Détection automatique des périphériques (USB débranché, NAS hors ligne)
- Versioning : historique par fichier (versions datées)
- CLI moderne (Typer + Rich) avec options dry-run et verbose
- Restauration granulaire : par fichier, dossier, date ou version
---
## Prérequis
- Python 3.10+
- Systèmes supportés : Windows 10/11, macOS (Intel/Apple Silicon) et distributions Linux modernes
- Destination de backup : dossier local, disque externe, NAS, clé USB, etc.
---
## Installation rapide
### Option A — Via PyPI (recommandé)
```bash
pip install cryptbackup
cryptbackup init
```
### Option B — Depuis le code source (développement)
1. Cloner le dépôt :
```bash
git clone https://github.com/stephdeve/backup-system.git
cd backup-system
```
2. Créer et activer un environnement virtuel :
- Windows PowerShell :
```powershell
python -m venv venv
.\venv\Scripts\Activate.ps1
```
- Windows CMD :
```bat
python -m venv venv
.\venv\Scripts\activate.bat
```
- macOS / Linux :
```bash
python -m venv venv
source venv/bin/activate
```
3. Installer les dépendances :
```bash
python -m pip install --upgrade pip
pip install -r requirements.txt
pip install -e .
```
---
## Initialisation
Initialiser CryptBackup (crée configuration, base de données et clé de chiffrement) :
```bash
cryptbackup init
```
Ceci crée automatiquement selon votre OS :
- Windows : `%USERPROFILE%\.mybackup\config.yaml` et `%USERPROFILE%\.mybackup\backups.db`
- macOS / Linux : `~/.mybackup/config.yaml` et `~/.mybackup/backups.db`
> **IMPORTANT** : Sauvegardez immédiatement votre `config.yaml` sur un support externe.
> Sans votre clé de chiffrement, la restauration est **impossible**.
---
## Utilisation
### Configurer les sources et destinations
Ajouter des dossiers à sauvegarder :
```bash
# Windows
cryptbackup add "C:\Users\VotreNom\Documents" --exclude "*.tmp,~*,desktop.ini"
# macOS / Linux
cryptbackup add "/home/votreuser/Documents" --exclude "*.tmp,~*,.DS_Store"
```
Configurer les destinations (voir section complète [Destinations supportées](#-destinations-supportées)) :
```bash
# Destination principale (dossier local)
cryptbackup config set destinations.primary "C:\Users\VotreNom\Backup"
# Destination secondaire (clé USB ou disque externe)
cryptbackup config set destinations.secondary "E:\Backup"
# Destination tertiaire (NAS réseau)
cryptbackup config set destinations.tertiary "\\192.168.1.100\backup"
```
Afficher la configuration :
```bash
cryptbackup config show
```
### Lancer un backup
Backup de toutes les sources :
```bash
cryptbackup backup
```
Backup d'une source particulière :
```bash
# Windows
cryptbackup backup --source "C:\Users\VotreNom\Documents"
# macOS / Linux
cryptbackup backup --source "/home/votreuser/Documents"
```
Backup intelligent (priorisation des fichiers importants) :
```bash
cryptbackup backup --smart
```
Simulation (dry-run) :
```bash
cryptbackup backup --dry-run --verbose
```
### Statut et historique
Afficher le statut :
```bash
cryptbackup status
```
Affiche : fichiers sauvegardés, espace utilisé / économisé, dernier backup, sources et **état de toutes les destinations**.
Lister les versions d'un fichier :
```bash
# Windows
cryptbackup list "C:\Users\VotreNom\Documents\rapport.pdf"
# macOS / Linux
cryptbackup list "/home/votreuser/Documents/rapport.pdf"
```
### Restaurations
Restaurer la dernière version d'un fichier :
```bash
# Windows
cryptbackup restore --file "C:\Users\VotreNom\Documents\important.docx"
# macOS / Linux
cryptbackup restore --file "/home/votreuser/Documents/important.docx"
```
Restaurer à une date spécifique :
```bash
cryptbackup restore --file "C:\Users\VotreNom\Documents\rapport.pdf" --date 2026-01-15
```
Restaurer une version précise :
```bash
cryptbackup restore --file "C:\Users\VotreNom\app.py" --version 3
```
Restaurer vers un autre emplacement :
```bash
# Windows
cryptbackup restore --file "C:\Users\VotreNom\doc.txt" --destination "C:\Restored\doc.txt"
# macOS / Linux
cryptbackup restore --file "/home/votreuser/doc.txt" --destination "/home/votreuser/Restored/doc.txt"
```
Restaurer tout un dossier :
```bash
# Windows
cryptbackup restore --directory "C:\Users\VotreNom\Documents" --destination "C:\Restored"
# macOS / Linux
cryptbackup restore --directory "/home/votreuser/Documents" --destination "/home/votreuser/Restored"
```
Lister tous les fichiers disponibles pour restauration :
```bash
cryptbackup restore --list
```
### Nettoyage / Rétention
```bash
# Conserver 30 jours et 10 versions par fichier
cryptbackup clean --keep-days 30 --keep-versions 10
# Simulation avant suppression
cryptbackup clean --dry-run
```
---
## Destinations supportées
CryptBackup supporte **4 types de destinations** simultanément.
Configurez jusqu'à 3 destinations pour une protection maximale selon la règle **3-2-1** :
*3 copies, 2 supports différents, 1 hors site.*
### Types de destinations
| Icône | Type | Exemple Windows | Exemple Linux/macOS |
|-------|------|-----------------|---------------------|
| 🖥️ | Dossier local (PC) | `C:\Users\Steve\Backup` | `/home/user/backup` |
| 🔌 | Clé USB | `E:\Backup` | `/media/user/usb/backup` |
| 💽 | Disque dur externe | `F:\Backup` | `/media/user/disk/backup` |
| 🌐 | NAS (réseau) | `\\192.168.1.100\backup` | `/mnt/nas/backup` |
### Configuration complète
#### Windows
```bash
# Dossier local sur le PC
cryptbackup config set destinations.primary "C:\Users\Steve\Backup"
# Clé USB ou disque externe
cryptbackup config set destinations.secondary "E:\Backup"
# NAS sur le réseau local
cryptbackup config set destinations.tertiary "\\192.168.1.100\backup"
```
#### Linux / macOS
```bash
# Dossier local
cryptbackup config set destinations.primary "/home/user/backup"
# Disque externe monté
cryptbackup config set destinations.secondary "/media/user/disk/backup"
# NAS monté
cryptbackup config set destinations.tertiary "/mnt/nas/backup"
```
### Vérification de l'état des destinations
```bash
cryptbackup status
```
**Toutes les destinations connectées :**
```
Destinations :
🖥️ [primary] C:\Users\Steve\Backup Libre : 45.2 GB
🔌 [secondary] E:\Backup Libre : 120.5 GB
🌐 [tertiary] \\192.168.1.100\backup Libre : 1.2 TB
```
**USB débranché — CryptBackup continue sur les autres :**
```
Destinations :
🖥️ [primary] C:\Users\Steve\Backup Libre : 45.2 GB
🔌 [secondary] E:\Backup Destination non trouvée (périphérique débranché ?)
🌐 [tertiary] \\192.168.1.100\backup Libre : 1.2 TB
```
> **Note :** Si une destination est inaccessible (USB débranché, NAS hors ligne), CryptBackup continue automatiquement vers les destinations disponibles et vous en informe.
---
## 🔧 Configuration avancée
Fichier de configuration :
- Windows : `%USERPROFILE%\.mybackup\config.yaml`
- macOS / Linux : `~/.mybackup/config.yaml`
Exemple de structure complète :
```yaml
version: '1.0.1'
created_at: '2026-01-20T14:30:00'
encryption:
algorithm: AES-256-GCM
key: 'VOTRE_CLE_SECRETE_ICI'
compression:
enabled: true
algorithm: zstd
level: 3 # 1 (rapide) à 22 (max compression)
sources:
- path: C:\Users\VotreNom\Documents
exclude: ['*.tmp', '~*', 'desktop.ini']
added_at: '2026-01-20T14:35:00'
destinations:
primary: C:\Users\VotreNom\Backup # Dossier local
secondary: E:\Backup # Clé USB / disque externe
tertiary: \\192.168.1.100\backup # NAS
watch:
enabled: true
interval: 300 # secondes
realtime: true
retention:
keep_days: 30
keep_versions: 10
auto_clean: false
```
Modifier via CLI :
```bash
cryptbackup config set compression.level 5
cryptbackup config set retention.auto_clean true
cryptbackup config set watch.interval 600
```
---
## Comment ça marche (aperçu technique)
Pour chaque fichier modifié :
1. Calcul du hash SHA-256 (détecte les modifications)
2. Compression Zstandard (zstd)
3. Chiffrement AES-256-GCM (Cryptography.io)
4. Stockage du binaire chiffré (`.enc`) sur chaque destination accessible
5. Enregistrement des métadonnées dans SQLite (hash, taille, timestamp, version)
Structure sur destination :
```
D:\Backups\
├── a3f5c892e1b4...enc (version 1 de app.py)
├── d9g3h456f2c8...enc (version 2 de app.py)
└── ...
```
La base de données contient : chemin original, version, hash, tailles (original / compressé / chiffré), timestamps, ratio de compression.
---
## 🔒 Sécurité
- Algorithme : AES-256-GCM (authentifié)
- Bibliothèque : cryptography (best-effort FIPS-aware usage)
- Intégrité : vérification SHA-256 avant et après chiffrement — corruption détectée à la restauration
- Permissions Unix : 700 (dossiers) / 600 (fichiers sensibles)
- Clé stockée dans `config.yaml` — **à sauvegarder hors-site impérativement**
Sauvegarde de la clé :
```powershell
# Windows
copy $env:USERPROFILE\.mybackup\config.yaml F:\backup_key.yaml
```
```bash
# macOS / Linux
cp ~/.mybackup/config.yaml /mnt/secure/backup_key.yaml
```
> Sans la clé : restauration **impossible**. Conservez plusieurs copies (clé USB, cloud chiffré, coffre physique).
---
## Dépannage
| Erreur | Solution |
|--------|----------|
| "CryptBackup n'est pas initialisé" | Exécuter `cryptbackup init` |
| "Destination manquante" | `cryptbackup config set destinations.primary "D:\Backups"` |
| "Clé de chiffrement invalide" | Restaurer votre `config.yaml` depuis votre copie de sauvegarde |
| Backup lent | Diminuer la compression (`level 1`) ou exclure plus de fichiers |
| Permission denied | Vérifier permissions NTFS (Windows) ou POSIX (Linux/macOS) |
| USB non détecté | Vérifier que le périphérique est monté, relancer `cryptbackup status` |
| NAS inaccessible | Vérifier la connexion réseau, les identifiants et le montage |
---
## Roadmap
### Terminé
- Backup incrémental avec chiffrement AES-256-GCM
- Compression Zstandard
- CLI moderne (Typer + Rich)
- Surveillance temps réel (watchdog)
- Priorisation intelligente des fichiers
- Destinations multiples (local, USB, disque externe, NAS)
- Détection automatique des périphériques
### En cours
- Dashboard web (FastAPI + interface graphique)
- Daemon de surveillance en arrière-plan (service système)
### Futur
- Support cloud chiffré (Backblaze B2, AWS S3)
- Application mobile (monitoring)
- Multi-utilisateurs (entreprises)
- API REST
---
## 🤝 Contribution
Suggestions et contributions bienvenues. Ouvrez une issue ou une pull request sur GitHub.
GitHub : [stephdeve/cryptbackup](https://github.com/stephdeve/cryptbackup)
PyPI : [pypi.org/project/cryptbackup](https://pypi.org/project/cryptbackup)
---
## Licence
MIT License — utilisation libre, modification et distribution autorisées.
---
## Auteur
**StephDev** — Développeur (Cotonou, Bénin). Projet réalisé dans le cadre d'un apprentissage Python avancé.
---
## Remerciements
- [cryptography.io](https://cryptography.io/) — Chiffrement AES-256
- [Zstandard](https://python-zstandard.readthedocs.io/) — Compression
- [Typer](https://typer.tiangolo.com/) — CLI moderne
- [Rich](https://rich.readthedocs.io/) — Interface terminal
- [Watchdog](https://python-watchdog.readthedocs.io/) — Surveillance fichiers
---
## ⚡ Quick Start (résumé)
```bash
# 1. Installer
pip install cryptbackup
# 2. Initialiser
cryptbackup init
# 3. Ajouter une source
cryptbackup add "C:\Users\VotreNom\Documents" # Windows
cryptbackup add "/home/votreuser/Documents" # Linux/macOS
# 4. Configurer les destinations
cryptbackup config set destinations.primary "C:\Users\VotreNom\Backup" # Local
cryptbackup config set destinations.secondary "E:\Backup" # USB / Externe
cryptbackup config set destinations.tertiary "\\192.168.1.100\backup" # NAS
# 5. Lancer un backup
cryptbackup backup
# 6. Vérifier l'état
cryptbackup status
# 7. Restaurer un fichier
cryptbackup restore --file "C:\Users\VotreNom\Documents\fichier.txt"
```
**Vos données sont maintenant protégées. 🎉**
| text/markdown | null | StephDev <dev@example.com> | null | null | MIT | backup, encryption, aes-256, nas, usb, zstandard | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: End Users/Desktop",
"Intended Audience :: System Administrators",
"Topic :: System :: Archiving :: Backup",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language ... | [] | null | null | >=3.10 | [] | [] | [] | [
"cryptography>=42.0.0",
"zstandard>=0.22.0",
"watchdog>=4.0.0",
"typer>=0.12.0",
"rich>=13.7.0",
"pyyaml>=6.0"
] | [] | [] | [] | [
"Homepage, https://github.com/stephdeve/cryptbackup",
"Bug Tracker, https://github.com/stephdeve/cryptbackup/issues",
"Documentation, https://github.com/stephdeve/cryptbackup#readme",
"PyPI, https://pypi.org/project/cryptbackup/"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-18T10:16:52.268437 | cryptbackup-1.0.6.tar.gz | 39,667 | 43/33/ac35ad1631617e5bf3bb33243a4d0a1239a61bfe180e18b802e38f19909c/cryptbackup-1.0.6.tar.gz | source | sdist | null | false | 2f1778082e91bc8e621b760b31bd8a6f | 7d2a7ac7039aa5cf36e037686e73669d82841c2025695b9f77d736911036405c | 4333ac35ad1631617e5bf3bb33243a4d0a1239a61bfe180e18b802e38f19909c | null | [] | 263 |
2.3 | xplor | 0.6.1 | A unified framework for Operation Research modeling with polars |
<img src="static/banner.png" alt="A polars based optimization framework" height="200px">
# xplor: A Modern DataFrame-Centric Optimization Framework
[](https://badge.fury.io/py/xplor)
[](https://opensource.org/licenses/MIT)
xplor provides a unified framework for building Operation Research models using [polars](https://pola.rs/) DataFrames. By leveraging polars' performance and ergonomic API, xplor makes mathematical optimization more intuitive and maintainable.
## Why xplor?
Building large-scale optimization models in Python can become **inefficient**. Standard approaches often require iterating over rows, manipulating Python dictionaries, or using slow list comprehensions, which makes the logic **slow and difficult to maintain** as the model grows.
**xplor** solves this core issue by using a **Polars-based DataFrame API** to construct your model logic. This provides two significant benefits:
1. **Vectorized Performance:** Model operations (like grouping, joining, filtering, and aggregation) are executed using **Polars' high-performance Rust backend**. You are no longer manipulating slow Python objects*; the logic is executed at native speed.
2. **Maintainability:** By relying on the familiar and expressive DataFrame API, your model logic becomes significantly **more readable and maintainable**.
Additionally, a huge benefit of `xplor` is its **solver agnosticism**. It abstracts away the specific syntax of underlying optimization engines (like Gurobi or MathOpt), allowing you to define a single model and easily benchmark its performance across multiple solvers.
\* Clarification: Variable, variable expression, and constraint objects themselves are still Python objects (e.g., `gurobi.Var` or `mathopt.Variable`), but the data manipulation and application of model logic are managed by Rust via Polars' User-Defined Functions (UDFs), enabling vectorized performance.
## Installation
**`xplor`** requires Python 3.11+.
Install the base package, which provides the core Polars integration and abstract modeling interface:
xplor comes with few dependencies. To use a specific solver you need to add optional dependency group.
```bash
pip install xplor[gurobi, ortools, cplex]
```
or install all of them
```bash
pip install xplor[all]
```
> **Note:** Gurobi requires a valid license (academic or commercial) to run. Please follow the [official Gurobi documentation](https://docs.gurobi.com/current/) for setup instructions.
>
> **Note:** CPLEX requires a valid license (academic or commercial) to run. Please follow the [official CPLEX documentation](https://ibmdecisionoptimization.github.io/docplex-doc/) for setup instructions.
## Quick Start
Have a look to the [documentation](https://gab23r.github.io/xplor/usage.html).
## 🟢 Current Status
`xplor` is in active development.
### Currently Supported Backends
* ✅ **Gurobi backend**
* ✅ **OR-Tools backend**
* ✅ **Hexaly backend**
* ✅ **CPLEX backend** (via docplex)
### Planned Features
* 🚧 Support for non-linear expressions.
* 🚧 Support for additional solvers (HiGHS, ...).
## Contributing
Want to contribute? Read our [contributing guide](https://gab23r.github.io/xplor/contributing.html).
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Acknowledgments
- [gurobipy-pandas](https://github.com/Gurobi/gurobipy-pandas) for inspiration.
- [polars](https://pola.rs/) for the amazing DataFrame library.
- [Gurobi](https://www.gurobi.com/) for the optimization solver.
- [OR-Tools](https://developers.google.com/optimization/math_opt) for the optimization solver.
- [IBM CPLEX](https://ibmdecisionoptimization.github.io/docplex-doc/) for the optimization solver.
| text/markdown | Gabriel Robin | null | null | null | MIT | optimization, polars, gurobi, mathopt, cplex, operations research | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"polars>=1.36.1",
"xplor[gurobi]; extra == \"all\"",
"xplor[ortools]; extra == \"all\"",
"xplor[hexaly]; extra == \"all\"",
"xplor[cplex]; extra == \"all\"",
"docplex>=2.27.239; extra == \"cplex\"",
"cplex>=22.1.2.0; extra == \"cplex\"",
"gurobipy>=11.0.3; extra == \"gurobi\"",
"scipy>=1.17.0; extra... | [] | [] | [] | [
"Homepage, https://github.com/gab23r/xplor",
"Repository, https://github.com/gab23r/xplor",
"Documentation, https://gab23r.github.io/xplor/",
"Bug Tracker, https://github.com/gab23r/xplor/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-18T10:15:25.527583 | xplor-0.6.1.tar.gz | 29,959 | b8/0c/0f1b391f5d74257647a2364707829cd592ebeb5f0d35d5cef00a8cd1d51d/xplor-0.6.1.tar.gz | source | sdist | null | false | c4a295ade7b3944a68b98ec176339073 | 49cb4e6b088aae9deab86972c0b2b2760b7713dbd28ade4b49d2cc3f5707c20f | b80c0f1b391f5d74257647a2364707829cd592ebeb5f0d35d5cef00a8cd1d51d | null | [] | 252 |
2.4 | djadyen | 4.1.0.dev1 | Django adyen payment integration | DjAdyen
=======
:Version: 4.1.0-dev1
:Source: https://github.com/maykinmedia/djadyen
:Keywords: django, adyen, payment
:PythonVersion: 3.9
|build-status| |code-quality| |ruff| |coverage|
|python-versions| |django-versions| |pypi-version|
.. contents::
.. section-numbering::
This module is used to connect your django application to the payment
provider Adyen using the `“Web
Components” <https://docs.adyen.com/online-payments/web-components>`__
and `“Web
Drop-in” <https://docs.adyen.com/online-payments/web-drop-in>`__
This is only tested on a postgres database.
Supported Ayden Payments
------------------------
- **Alipay** - adyen name: ``alipay``
- **Bancontact** card - adyen name: ``bcmc``, uses brands
- **(Debit/Credit) Card** - adyen name: ``schema``, uses brands
- **Finnish E-Banking** - adyen name: ``ebanking_FI``
- **iDEAL** - adyen name: ``ideal``
- **SEPA Bank Transfer** - adyen name: ``bankTransfer_IBAN``
- **SEPA Direct Debit** - adyen name: ``sepadirectdebit``
Issuers & Brands
~~~~~~~~~~~~~~~~
Both issuers and brands are used for ``AdyenIssuer`` objects for
different payment options. Some will use one ``adyen_id`` for one issuer
while some others will use a list of ``adyen_id``\ s for allowed brands.
Installation
------------
Install with pip
.. code:: shell
pip install djadyen
Add *‘djadyen’* to the installed apps
.. code:: python
# settings.py
INSTALLED_APPS = [
...
'djadyen',
...
]
Add the Adyen notifications urls (This is not required). These url will
save all the notifications to the database. You need to make an
implementation to handle the notifications
.. code:: python
# urls.py
urlpatterns = [
...
url(r'^adyen/notifications/', include('djadyen.notifications.urls', namespace='adyen-notifications')),
...
]
.. code:: python
# models.py
from djadyen.models import AdyenOrder
class CustomOrder(AdyenOrder):
def get_price_in_cents(self):
"""
:return int Return the price in cents for this order.
"""
raise NotImplementedError
def get_return_url(self):
raise NotImplementedError(
"Please override 'get_return_url' on the '{model_name}'".format(
model_name=self.\_meta.object_name
)
)
Usage
-----
Management command
~~~~~~~~~~~~~~~~~~
There is a management command that will sync the payment methods for
you. This can be used if you want the users to select a payment
method/issuer on your own site.
``manage.py sync_payment_methods``
There is a command that will call the function ``process_notification``
to handle notifications. This can be added to a crontab.
``manage.py adyen_maintenance``
Required settings
~~~~~~~~~~~~~~~~~
- ``DJADYEN_SERVER_KEY`` *This is the server key. This should be a
secret string.*
- ``DJADYEN_CLIENT_KEY`` *This is the client key. This key will be used
in the components in the frontend.*
- ``DJADYEN_MERCHANT_ACCOUNT`` *This is the merchant accont that is
used in Adyen.*
- ``DJADYEN_ORDER_MODELS`` *A list of models that are used to store
Orders (Inherit from AdyenOrder). The models should be strings in the
. form*
- ``DJADYEN_NOTIFICATION_KEY`` *The key to verify the notifications are
from adyen*
Optional settings
~~~~~~~~~~~~~~~~~
- ``DJADYEN_CURRENCYCODE`` *(default=‘EUR’) This can be set to any
other currency Adyen supports.*
- ``DJADYEN_ENVIRONMENT`` *(default=‘test’) This can be ‘test’ or
‘live’.*
- ``DJADYEN_APPNAME`` *(default=‘Djadyen Payment’) This is the name
that will be send along with the payment.*
- ``DJADYEN_REFETCH_OLD_STATUS`` *(default=False) This is so you will
always have the latest saved status. This will cause an extra db
query!*
- ``DJADYEN_HANDLE_NOTIFICATION_MINUTES_AGO`` *(default=15) This
defaults to 15 minutes. You can change the value to make this shorter
or longer depending on the need.*
DJADYEN_STYLES
^^^^^^^^^^^^^^
(Optional) Customize the appearance of Adyen payment components.
This setting allows you to configure the styling of Adyen Web Components
by providing style definitions that are passed to the payment component
configuration. This enables you to customize colors, fonts, and other
visual properties of the payment form fields.
**Example:**
.. code:: python
# settings.py
DJADYEN_STYLES = {
'base': {
'color': '#000000',
'fontSize': '16px',
'fontFamily': 'Arial, sans-serif',
},
'placeholder': {
'color': '#999999',
},
'error': {
'color': '#ff0000',
},
'validated': {
'color': '#00ff00',
}
}
**How it works:**
The styles object is passed to the Adyen payment component
configuration, allowing you to customize the appearance of input fields.
The configuration supports several style categories:
- ``base``: Default styling for form input fields
- ``placeholder``: Styling for placeholder text
- ``error``: Styling for fields in an error state
- ``validated``: Styling for successfully validated fields
**Available style properties:**
Within each category, you can use properties like: - ``color``: Text
color - ``fontSize``: Font size (e.g., ‘16px’, ‘1rem’) - ``fontFamily``:
Font family - ``fontWeight``: Font weight - ``lineHeight``: Line height
- And other CSS-like properties supported by Adyen components
For a complete list of available styling options and examples, refer to
the `Adyen Card Component Styling
Documentation <https://docs.adyen.com/payment-methods/cards/custom-card-integration/#styling>`__.
**Note:** These styles apply specifically to Adyen’s secured fields
(like card number, CVV, expiry date). For styling the container or other
elements, use regular CSS in your stylesheets.
If ``DJADYEN_STYLES`` is not set, Adyen’s default styling will be used.
Order object
~~~~~~~~~~~~
There is an abstract order in this package. This will save you some time
on creating an order for adyen. There are some features on the order
that will make it easier to integrate your order with this package.
The added fields are:
- ``status`` *This is the status of the object. This will be changed by
adyen.*
- ``created_at`` *This field is used for when the order is created.*
- ``reference`` *This field is a communication field. It is not used
outside the communication. This will be set by uuid4, but can be
overwritten.*
- ``psp_reference`` *This field is the reference from Adyen. With this
field you are able to search in the Adyen inderface.*
- ``payment_option`` *This is the Adyen payment option from this
package.*
- ``issuer`` *This is the Adyen issuer from this package.*
You should implement the following methods
- ``get_price_in_cents`` *Return the price to be paid for this order*
- ``process_authorized_notification`` *Process a ‘authorized’
notification which adyen has sent*
- ``process_notification`` *Process the notification, if you are using
the adyen-maintenance management command*
AdyenPaymentView
~~~~~~~~~~~~~~~~
This view is used to show the payment page.
This page can be customized in 2 ways.
1. overwrite the template (``adyen/pay,html``)
2. Overwrite the view and changing the ``template_name``
.. code:: python
from djadyen.views import AdyenPaymentView
class PaymentView(AdyenPaymentView):
template_name = "my_adyen/pay.html" # Optional
Adyen requires a language locale i.e. ``nl-NL`` or ``en-US`` instead of
``nl`` or ``en``. If Django’s uses language codes, ``adyen_language``
should be converted in the view context similarly to this:
.. code:: python
ADYEN_LANGUAGES = {
"nl": "nl-NL",
"en": "en-US",
}
class PaymentView(AdyenPaymentView):
...
def get_context_data(self, **kwargs):
return super().get_context_data(**kwargs) | {"adyen_language": ADYEN_LANGUAGES[self.request.LANGUAGE_CODE]}
AdyenResponseView
~~~~~~~~~~~~~~~~~
Adyen also creates a response. This will help you with catching the
response. This view will check if the response from Adyen is valid. It
will also provide some usefull functions so you don’t have to overwrite
anything.
In this example the order is automaticly fetched from the reference that
is passed in the merchantReference. It will also set the order in the
self object for easy access. In the done function the order is saved and
the template will be rendered.
.. code:: python
from djadyen.views import AdyenResponseView
from djadyen.choices import Status
class ConfirmationView(AdyenResponseView, TemplateView):
template_name = 'my_project/confirmation.html'
model = Order
def handle_authorised(self):
self.order.status = Status.Authorised
return self.done()
Adyen notifications
===================
Setup the standard notifications in Adyen. These will comunicate about
the payments if they were succesful or not. This is **very important**
because the notifications will be needed when a payment is redirected
with a pending payment.
The notifications will be stored in the database. You need to write the
handling of the notifications yourself or use the ``adyen_maintenance``
command.
License
-------
|FOSSA Status|
.. |build-status| image:: https://github.com/maykinmedia/djadyen/workflows/Run%20CI/badge.svg
:alt: Build status
:target: https://github.com/maykinmedia/djadyen/actions?query=workflow%3A%22Run+CI%22
.. |code-quality| image:: https://github.com/maykinmedia/djadyen/workflows/Code%20quality%20checks/badge.svg
:alt: Code quality checks
:target: https://github.com/maykinmedia/djadyen/actions?query=workflow%3A%22Code+quality+checks%22
.. |ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
:target: https://github.com/astral-sh/ruff
:alt: Ruff
.. |coverage| image:: https://codecov.io/gh/maykinmedia/djadyen/branch/main/graph/badge.svg
:target: https://codecov.io/gh/maykinmedia/djadyen
:alt: Coverage status
.. |docs| image:: https://readthedocs.org/projects/djadyen/badge/?version=latest
:target: https://djadyen.readthedocs.io/en/latest/?badge=latest
:alt: Documentation Status
.. |python-versions| image:: https://img.shields.io/pypi/pyversions/djadyen.svg
.. |django-versions| image:: https://img.shields.io/pypi/djversions/djadyen.svg
.. |pypi-version| image:: https://img.shields.io/pypi/v/djadyen.svg
:target: https://pypi.org/project/djadyen/
.. |FOSSA Status| image:: https://app.fossa.io/api/projects/git%2Bgithub.com%2Fmaykinmedia%2Fdjadyen.svg?type=large
:target: https://app.fossa.io/projects/git%2Bgithub.com%2Fmaykinmedia%2Fdjadyen?ref=badge_large
| text/x-rst | null | Maykin Media <support@maykinmedia.nl> | null | null | null | django, adyen, payment | [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Framework :: Django :: 3.2",
"Framework :: Django :: 4.2",
"Framework :: Django :: 5.2",
"Intended Audience :: Developers",
"Operating System :: Unix",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows",
"Programming L... | [] | null | null | >=3.9 | [] | [] | [] | [
"Adyen>=10.0.0",
"django>=3.2",
"requests",
"glom",
"pytest; extra == \"tests\"",
"pytest-django; extra == \"tests\"",
"pytest-cov; extra == \"tests\"",
"django-webtest; extra == \"tests\"",
"requests-mock; extra == \"tests\"",
"factory-boy; extra == \"tests\"",
"freezegun; extra == \"tests\"",
... | [] | [] | [] | [
"Homepage, https://github.com/maykinmedia/djadyen",
"Changelog, https://github.com/maykinmedia/djadyen/blob/master/CHANGELOG.md"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:14:09.412025 | djadyen-4.1.0.dev1.tar.gz | 262,294 | 0f/9f/a329d6b9c001084b482562967d0073700bd001c406ffa13fea502d1d6e28/djadyen-4.1.0.dev1.tar.gz | source | sdist | null | false | d4e97f266949518758347eb3c551c7fc | e9b7f0a407f5fb82efb3d1672aae9739773512a2cf48c06d78fa7e3c1ee3feb8 | 0f9fa329d6b9c001084b482562967d0073700bd001c406ffa13fea502d1d6e28 | MIT | [] | 233 |
2.4 | axsdb | 0.1.2 | An absorption database reader for the Eradiate radiative transfer model. | # AxsDB — The Eradiate Absorption Cross-section Database Interface
[](https://pypi.org/project/axsdb)
[](https://github.com/eradiate/axsdb/actions/workflows/ci.yml)
[](https://axsdb.readthedocs.io)
[](https://github.com/astral-sh/uv)
[](https://github.com/astral-sh/ruff)
This library provides an interface to read and query the absorption databases
of the [Eradiate radiative transfer model](https://eradiate.eu).
## Features
- **Monochromatic and CKD databases**: Read and evaluate absorption coefficients
for both monochromatic and correlated-k distribution spectral representations.
- **Fast interpolation**: Numba-accelerated multi-dimensional interpolation of
thermophysical profiles (pressure, temperature, mole fractions).
- **Configurable error handling**: Fine-grained, per-coordinate control over
out-of-bounds behaviour (clamp, fill, raise, warn).
- **Efficient I/O**: Lazy or eager loading of NetCDF data files, with LRU
caching for repeated lookups.
- **xarray and Pint integration**: Works natively with xarray datasets and
Pint quantities.
- **CLI**: Validate database integrity from the command line with `axsdb check`.
## Installation
Python 3.9 or later is required.
```shell
pip install axsdb
```
## Quick start
```python
import xarray as xr
from axsdb import MonoAbsorptionDatabase
from axsdb.units import get_unit_registry
ureg = get_unit_registry()
# Open a database directory
db = MonoAbsorptionDatabase.from_directory("path/to/database")
# Load a thermophysical profile
thermoprops = xr.load_dataset("path/to/thermoprops.nc")
# Evaluate the absorption coefficient at a given wavelength
sigma_a = db.eval_sigma_a_mono(
w=550.0 * ureg.nm,
thermoprops=thermoprops,
)
```
For CKD databases, use `CKDAbsorptionDatabase` and `eval_sigma_a_ckd` (which
takes an additional `g` parameter for the quadrature point).
## CLI
AxsDB ships a command-line tool to validate databases:
```shell
# Check a monochromatic database
axsdb check path/to/database -m mono
# Check and fix missing index files
axsdb check path/to/database -m ckd --fix
```
## Documentation
Full documentation is available at
[axsdb.readthedocs.io](https://axsdb.readthedocs.io).
## License
AxsDB is distributed under the terms of the
[GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/).
| text/markdown | null | Vincent Leroy <vincent.leroy@rayference.eu> | null | null | null | absorption, atmosphere, eradiate, radiative-transfer, spectroscopy | [
"Development Status :: 4 - Beta",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language... | [] | null | null | >=3.9 | [] | [] | [] | [
"attrs",
"cachetools",
"netcdf4",
"numba>=0.58",
"pint",
"scipy",
"typer",
"xarray>=2024.7.0"
] | [] | [] | [] | [
"Homepage, https://github.com/eradiate/axsdb",
"Documentation, https://axsdb.readthedocs.io",
"Repository, https://github.com/eradiate/axsdb",
"Changelog, https://github.com/eradiate/axsdb/blob/main/CHANGELOG.md"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:13:33.388280 | axsdb-0.1.2.tar.gz | 2,810,463 | 0b/1b/de2cd5a61f094e2db1f3856ac9e15f607dcd636db6f6ab9069290fb99286/axsdb-0.1.2.tar.gz | source | sdist | null | false | 245ec121de60cc25f8c4d3b0d0a734e4 | 1fcb7f41dcaa5ce73f83ebdaa76f746576cf250b26654c47e0015397d7773695 | 0b1bde2cd5a61f094e2db1f3856ac9e15f607dcd636db6f6ab9069290fb99286 | LGPL-3.0-or-later | [
"LICENSE"
] | 321 |
2.4 | teamvault | 0.11.7 | Keep your passwords behind the firewall | # TeamVault
TeamVault is an open-source web-based shared password manager for behind-the-firewall installation. It requires Python 3.10+ and PostgreSQL (with the unaccent extension).
## Installation
apt-get install libffi-dev libldap2-dev libpq-dev libsasl2-dev python3.X-dev postgresql-contrib
pip install teamvault
teamvault setup
vim /etc/teamvault.conf
# note that the teamvault database user will need SUPERUSER privileges
# during this step in order to activate the unaccent extension
teamvault upgrade
teamvault plumbing createsuperuser
teamvault run
## Update
pip install --upgrade teamvault
teamvault upgrade
## Development
### Start a PostgreSQL database
Create a database and superuser for TeamVault to use, for example by starting a Docker container:
docker run --rm --detach --publish=5432:5432 --name teamvault-postgres -e POSTGRES_USER=teamvault -e POSTGRES_PASSWORD=teamvault postgres:latest
### Run Webpack to serve static files
To compile all JS & SCSS files, you'll need to install all required packages via bun (or yarn/npm) with node >= v18.
Use ```bun/yarn/npm run serve``` to start a dev server.
**Note**:
Some MacOS users have reported errors when running the dev server via bun. In this case feel free to switch to NPM.
### Configure your Virtualenv via uv
uv sync
### Setup TeamVault
export TEAMVAULT_CONFIG_FILE=teamvault.cfg
teamvault setup
vim teamvault.cfg # base_url = http://localhost:8000
# session_cookie_secure = False
# database config as needed
teamvault upgrade
teamvault plumbing createsuperuser
### Start the development server
teamvault run
Now open http://localhost:8000
## Scheduled background jobs
We use [huey](https://huey.readthedocs.io/en/latest/) to run background jobs. This requires you to run a second process, in parallel to TeamVault itself. You can launch it via `manage.py`:
teamvault run_huey
## Release process
1. Bump the version in ```teamvault/__version__.py``` and ```pyproject.toml```
2. Update CHANGELOG.md with the new version and current date
3. Make a release commit with the changes made above
4. Push the commit
5. Run ```./build.sh``` to create a new package
6. Sign and push the artifacts to PyPI via ```uv publish```
7. Test that the package can be installed: ```uv run --isolated --no-cache --prerelease allow --with teamvault --no-project -- teamvault --version```
8. Add a new GitHub release
| text/markdown | Seibert Group GmbH | null | null | null | null | password, safe, manager, sharing | [
"Development Status :: 3 - Alpha",
"Environment :: Web Environment",
"Framework :: Django",
"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
"Natural Language :: English",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 3",
"Programming Language :: Python ::... | [] | null | null | >=3.12 | [] | [] | [] | [
"cryptography~=46.0.4",
"django-auth-ldap~=5.3.0",
"django-bootstrap5==26.2",
"django-filter==25.2",
"django-htmx~=1.27.0",
"django-test-migrations>=1.5.0",
"django-webpack-loader~=3.2.3",
"django~=6.0.2",
"djangorestframework~=3.16.1",
"gunicorn~=25.0.3",
"hashids~=1.3.1",
"pyotp~=2.9",
"hu... | [] | [] | [] | [
"Source, https://github.com/seibert-media/teamvault"
] | 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-18T10:12:01.731924 | teamvault-0.11.7-py3-none-any.whl | 5,896,837 | d9/36/b27c4cd0c15457368b614d9bcc337779e7325ff8905da812a105668a8379/teamvault-0.11.7-py3-none-any.whl | py3 | bdist_wheel | null | false | ed5984d32cd13bfc74203b6ad05ee23c | aee56d9d8a3bdc54b95562e059202c46cc0f85d8ab77cf222f636d2873480f6b | d936b27c4cd0c15457368b614d9bcc337779e7325ff8905da812a105668a8379 | null | [
"LICENSE"
] | 252 |
2.4 | caddytail | 0.5.1 | Caddy web server with Tailscale plugin, packaged for pip installation | # caddytail
Caddy web server with the [Tailscale plugin](https://github.com/tailscale/caddy-tailscale), packaged for pip installation. Run any Python web app on your tailnet with one command — Flask, FastAPI, Django, or any WSGI/ASGI callable.
## Installation
```bash
pip install caddytail # bare WSGI apps — no extra deps
pip install caddytail[flask] # Flask support
pip install caddytail[fastapi] # FastAPI / Starlette support
```
## Quick Start
Write a normal Flask app — no CaddyTail-specific setup needed:
```python
# app.py
from flask import Flask
from caddytail import get_user
app = Flask(__name__)
@app.get("/")
def index():
user = get_user()
return f"Hello, {user.name}!"
```
Or use any WSGI callable — no framework required:
```python
# app.py
from caddytail import get_user
def app(environ, start_response):
user = get_user(environ)
body = f"Hello, {user.name}!" if user else "Not authenticated"
start_response("200 OK", [("Content-Type", "text/plain")])
return [body.encode()]
```
Run it on your tailnet:
```bash
caddytail run myapp app:app
```
That's it. Your app is now available at `https://myapp.<tailnet>.ts.net` with Tailscale authentication.
## CLI
Hostname is always the first positional argument:
```bash
# Development — foreground, Ctrl-C kills everything
caddytail run <hostname> <app_ref> [--debug]
# Production — install as systemd service + tail logs
caddytail install <hostname> <app_ref> [--no-start] [--env K=V]
# Service management
caddytail status <hostname>
caddytail logs <hostname> [-n LINES] [-f]
caddytail restart <hostname>
caddytail uninstall <hostname>
# List all installed services
caddytail list
# Raw Caddy pass-through
caddytail caddy [args...]
```
The `<app_ref>` format is `module:variable` (like uvicorn), defaulting the variable to `app`:
- `app:app` — import `app` from `app.py`
- `myproject.main:application` — import `application` from `myproject/main.py`
- `app` — shorthand for `app:app`
### Behavior
- **`run`** — starts Caddy + your app in the foreground. Ctrl-C kills everything. The framework is auto-detected: Flask and FastAPI get framework-specific middleware; generic WSGI apps are served with `wsgiref`; generic ASGI apps are served with `uvicorn`.
- **`install`** — writes a systemd unit file (ExecStart = `caddytail run ...`), enables, starts. If stdout is a tty, automatically tails logs. Ctrl-C stops tailing but leaves the service running.
- **`uninstall`** — stops, disables, and removes the unit file.
- **`caddy`** — passes all remaining args to the bundled Caddy binary.
## Python API
### `get_user()`
Returns a `TailscaleUser` with `.name`, `.login`, `.profile_pic`:
```python
from caddytail import get_user
# Flask — no arguments needed (uses flask.request automatically)
user = get_user()
# FastAPI / Starlette — pass the Request object
user = get_user(request)
# WSGI — pass the environ dict
user = get_user(environ)
# Django — pass request.META
user = get_user(request.META)
if user:
print(user.name) # "John Doe"
print(user.login) # "john@example.com"
print(user.profile_pic) # "https://..."
```
### `login_required`
Works as both a Flask decorator and a FastAPI `Depends()` target:
```python
from caddytail import login_required
# Flask
@app.get("/secret")
@login_required
def secret():
user = get_user()
return f"Hello, {user.name}!"
# FastAPI
@app.get("/secret")
async def secret(user=Depends(login_required)):
return {"message": f"Hello, {user.name}!"}
```
### `static()`
Register static file paths to be served directly by Caddy:
```python
from caddytail import static
static(app, "/assets/*", "./static")
static(app, "/uploads/*", "/var/www/uploads")
```
The runner picks these up automatically when starting Caddy.
### `CaddyTail` class
For programmatic use (most users should use the CLI runner instead):
```python
from caddytail import CaddyTail
caddy = CaddyTail(app, "myapp", debug=True)
caddy.run()
```
All ports are auto-allocated. No conflicts when running multiple apps.
## Framework Examples
### FastAPI
```python
from fastapi import FastAPI, Request, Depends
from caddytail import get_user, login_required
app = FastAPI()
@app.get("/")
async def index(request: Request):
user = get_user(request)
return {"message": f"Hello, {user.name}!"}
@app.get("/protected")
async def protected(user=Depends(login_required)):
return {"message": f"Hello, {user.name}!"}
```
### Django
```python
# views.py
from django.http import HttpResponse
from caddytail import get_user
def index(request):
user = get_user(request.META)
return HttpResponse(f"Hello, {user.name}!")
```
### Bare WSGI
```python
from caddytail import get_user
def app(environ, start_response):
user = get_user(environ)
body = f"Hello, {user.name}!" if user else "Not authenticated"
start_response("200 OK", [("Content-Type", "text/plain")])
return [body.encode()]
```
### ASGI
```python
from caddytail import get_user
async def app(scope, receive, send):
# For ASGI apps, extract headers from the scope manually
...
```
All examples are run the same way:
```bash
caddytail run myapp myproject:app
```
## Supported Platforms
Pre-built wheels are available for:
| Platform | Architecture |
|----------|--------------|
| Linux (glibc) | x86_64, aarch64 |
| macOS | x86_64 (Intel), arm64 (Apple Silicon) |
| Windows | x86_64 |
## Building from Source
```bash
git clone https://github.com/jpc/caddytail
cd caddytail
# Install Go and xcaddy
go install github.com/caddyserver/xcaddy/cmd/xcaddy@latest
# Build caddy with the tailscale plugin
xcaddy build --with github.com/tailscale/caddy-tailscale --output src/caddytail/bin/caddy
# Build the wheel
pip install build
python -m build --wheel
```
## License
This project packages Caddy (Apache 2.0 License) with the Tailscale plugin (BSD 3-Clause License).
## Links
- [Caddy](https://caddyserver.com/)
- [Tailscale](https://tailscale.com/)
- [caddy-tailscale plugin](https://github.com/tailscale/caddy-tailscale)
- [xcaddy](https://github.com/caddyserver/xcaddy)
| text/markdown | null | Jakub Piotr Cłapa <jpc@loee.pl> | null | null | Apache-2.0 | caddy, tailscale, web-server, reverse-proxy, vpn | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: Apache Software License",
"Operating System :: MacOS",
"Operating System :: Microsoft :: Windows",
"Operating System :: POSIX :: Linu... | [] | null | null | >=3.8 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/jpc/caddytail",
"Repository, https://github.com/jpc/caddytail",
"Issues, https://github.com/jpc/caddytail/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:12:01.602794 | caddytail-0.5.1.tar.gz | 24,664 | e7/5d/c3b87896e18eaf6219fd1322f442d3ee50efb170dda467b783c810640117/caddytail-0.5.1.tar.gz | source | sdist | null | false | e8911bcaaa3fbce63014e1cc1de59138 | 30726898b448e053c45986e1b737a27db961f0d716bbfbed9559bd3c47b92e48 | e75dc3b87896e18eaf6219fd1322f442d3ee50efb170dda467b783c810640117 | null | [] | 541 |
2.4 | mcp-simple-timeserver | 3.3.2 | A simple MCP server that provides current time - either local or from an NTP server. | [](https://mseep.ai/app/andybrandt-mcp-simple-timeserver)
# MCP Simple Timeserver
[](https://archestra.ai/mcp-catalog/andybrandt__mcp-simple-timeserver)
[](https://smithery.ai/server/mcp-simple-timeserver)
*One of the strange design decisions Anthropic made was depriving Claude of timestamps for messages sent by the user in claude.ai or current time in general. Poor Claude can't tell what time it is! `mcp-simple-timeserver` is a simple MCP server that fixes that.*
## Available Tools
This server provides the following tools:
| Tool | Description |
|------|-------------|
| `get_local_time` | Returns the current local time, day of week, and timezone from the user's machine |
| `get_utc` | Returns accurate UTC time from an [NTP time server](https://en.wikipedia.org/wiki/Network_Time_Protocol) |
| `get_current_time` | Returns current time with optional location, timezone, and calendar conversions |
| `calculate_time_distance` | Calculates duration between two dates/times (countdowns, elapsed time) |
| `get_holidays` | Returns public holidays (and optionally school holidays) for a country |
| `is_holiday` | Checks if a specific date is a holiday in a given country or city |
All tools (except `get_local_time`) use accurate time from NTP servers. If NTP is unavailable, they gracefully fall back to local server time with a notice.
### Location Support via `get_current_time`
The `get_current_time` tool supports location parameters to get local time anywhere in the world:
| Parameter | Description | Example |
|-----------|-------------|---------|
| `city` | City name (primary use case) | `"Warsaw"`, `"Tokyo"`, `"New York"` |
| `country` | Country name or ISO code | `"Poland"`, `"JP"`, `"United States"` |
| `timezone` | IANA timezone or UTC offset | `"Europe/Warsaw"`, `"+05:30"` |
Priority: `timezone` > `city` > `country`. When location is provided, the response includes local time, timezone info, UTC offset, and DST status.
If today is a public holiday at the specified location, it will be shown in the output.
### Calendar Support via `get_current_time`
The `get_current_time` tool also accepts an optional `calendar` parameter with a comma-separated list of calendar formats:
| Calendar | Description |
|----------|-------------|
| `unix` | Unix timestamp (seconds since 1970-01-01) |
| `isodate` | ISO 8601 week date (e.g., `2026-W03-6`) |
| `hijri` | Islamic/Hijri lunar calendar |
| `japanese` | Japanese Era calendar (returns both English and Kanji) |
| `hebrew` | Hebrew/Jewish calendar (returns both English and Hebrew, includes holidays) |
| `persian` | Persian/Jalali calendar (returns both English and Farsi) |
Example: `get_current_time(city="Tokyo", calendar="japanese")` returns Tokyo local time with Japanese Era calendar.
### Time Distance Calculation via `calculate_time_distance`
Calculate duration between two dates or times:
| Parameter | Description | Example |
|-----------|-------------|---------|
| `from_date` | Start date (ISO 8601 or "now") | `"2025-01-15"`, `"now"` |
| `to_date` | End date (ISO 8601 or "now") | `"2025-12-31"`, `"2025-06-01T17:00:00"` |
| `unit` | Output format | `"auto"`, `"days"`, `"weeks"`, `"hours"`, `"minutes"`, `"seconds"` |
| `business_days` | Count only Mon-Fri (date-based, inclusive) | `true` |
| `exclude_holidays` | Also exclude public holidays (requires country/city) | `true` |
Location parameters (`city`, `country`, `timezone`) can also be used to specify timezone context.
When `business_days=true`, time-of-day is ignored and dates are counted as full days (inclusive endpoints).
The `unit` parameter is ignored in this mode. Holidays are excluded only when they fall on weekdays.
Example: `calculate_time_distance(from_date="now", to_date="2025-12-31")` returns a countdown to New Year's Eve.
Example: `calculate_time_distance(from_date="2026-01-26", to_date="2026-01-30", business_days=true, exclude_holidays=true, city="Sydney")` returns the number of business days in that range.
### Holiday Information via `get_holidays` and `is_holiday`
Get public and school holiday information for ~119 countries:
**`get_holidays`** parameters:
| Parameter | Description | Example |
|-----------|-------------|---------|
| `country` | Country name or ISO code (required) | `"Poland"`, `"DE"`, `"United States"` |
| `year` | Year to get holidays for (default: current year) | `2026` |
| `include_school_holidays` | Include school vacation periods | `true` |
**`is_holiday`** parameters:
| Parameter | Description | Example |
|-----------|-------------|---------|
| `country` | Country name or ISO code | `"Poland"`, `"US"` |
| `city` | City name for region-specific info | `"Warsaw"`, `"Munich"` |
| `date` | Date to check in ISO format (default: today) | `"2026-01-01"` |
**Regional School Holidays**: When using the `city` parameter with `is_holiday`, school holidays are filtered to show only those affecting the specific region. This is particularly useful in countries where school holidays vary by region (e.g., Polish voivodeships, German Bundesländer, Spanish autonomous communities).
Example: `is_holiday(city="Warsaw", date="2026-01-19")` returns school holiday information specific to the Mazowieckie voivodeship.
**Data Sources**:
- Public holidays: [Nager.Date API](https://date.nager.at/) (119 countries)
- School holidays: [OpenHolidaysAPI](https://openholidaysapi.org/) (36 countries, mostly European)
## Installation
### Installing via Smithery
To install Simple Timeserver for Claude Desktop automatically via [Smithery](https://smithery.ai/server/mcp-simple-timeserver):
```bash
npx -y @smithery/cli install mcp-simple-timeserver --client claude
```
### Manual Installation
First install the module using:
```bash
pip install mcp-simple-timeserver
```
Then configure in MCP client - the [Claude desktop app](https://claude.ai/download).
Under Mac OS this will look like this:
```json
"mcpServers": {
"simple-timeserver": {
"command": "python",
"args": ["-m", "mcp_simple_timeserver"]
}
}
```
Under Windows you have to check the path to your Python executable using `where python` in the `cmd` (Windows command line).
Typical configuration would look like this:
```json
"mcpServers": {
"simple-timeserver": {
"command": "C:\\Users\\YOUR_USERNAME\\AppData\\Local\\Programs\\Python\\Python311\\python.exe",
"args": ["-m", "mcp_simple_timeserver"]
}
}
```
## Web Server Variant
This project also includes a network-hostable version that can be deployed as a standalone web server. For instructions on how to run and deploy it, please see the [Web Server Deployment Guide](WEB_DEPLOYMENT.md).
Or you can simply use my server by adding it under https://mcp.andybrandt.net/timeserver to Claude and other tools that support MCP.
| text/markdown | null | Andy Brandt <andy@codesprinters.com> | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"fastmcp<4.0,>=3.0",
"ntplib",
"hijridate",
"japanera",
"pyluach",
"persiantools",
"pywin32; sys_platform == \"win32\"",
"timezonefinder>=6.0",
"requests>=2.28",
"tzdata",
"pycountry>=24.0",
"fastmcp[cli]; extra == \"cli\""
] | [] | [] | [] | [
"Homepage, https://github.com/andybrandt/mcp-simple-timeserver"
] | twine/6.2.0 CPython/3.13.11 | 2026-02-18T10:11:52.527501 | mcp_simple_timeserver-3.3.2.tar.gz | 27,932 | 3a/29/b8f902eabc6ca37b9bd19c8c85507010f47411d91fe74ff7f75a3eb9d101/mcp_simple_timeserver-3.3.2.tar.gz | source | sdist | null | false | dc62a9dbb1baf29eb0e228ade44ea987 | 5ee9594628a5493fc7e467ff3ce80ee8202dfaeb29ab7da7aeef28e00adfe133 | 3a29b8f902eabc6ca37b9bd19c8c85507010f47411d91fe74ff7f75a3eb9d101 | null | [
"LICENSE"
] | 302 |
2.4 | mcp-rlm-proxy | 0.1.1 | MCP-RLM-Proxy: Intelligent MCP middleware with RLM-style recursive exploration, smart caching, and proxy tools. | # MCP-RLM-Proxy: Intelligent Middleware for MCP Servers
> **Production-ready middleware** implementing Recursive Language Model principles ([arXiv:2512.24601](https://arxiv.org/abs/2512.24601)) for efficient multi-server management, automatic large-response handling, and first-class proxy tools for recursive data exploration. **100% compatible with the MCP specification** - works with any existing MCP server without modification.
## Quick Start for Current MCP Users
**Already using MCP servers?** Add this as middleware in 5 minutes:
```bash
# 1. Install
pip install mcp-rlm-proxy
# 2. Create a config in your working directory (mcp.json)
mcp-rlm-proxy --init-config ./mcp.json
# 3. Edit mcp.json to add your servers
$EDITOR ./mcp.json
# 2. Configure your existing servers
cat > mcp.json << EOF
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/your/path"]
}
}
}
EOF
# 3. Run the proxy
mcp-rlm-proxy --config ./mcp.json
```
**That's it!** Your servers now have automatic large-response handling and three powerful proxy tools for recursive exploration.
---
## Why Use This as Middleware?
### The Problem with Direct MCP Connections
When AI agents connect directly to MCP servers:
- **Token waste**: 85-95% of returned data is often unnecessary
- **Context pollution**: Irrelevant data dilutes important information
- **No multi-server aggregation**: Must connect to each server separately
- **Performance degradation**: Large responses slow everything down
- **Cost explosion**: Every unnecessary token costs money
### The Solution: Intelligent Middleware
```
+---------------+
| MCP Client | (Claude Desktop, Cursor, Custom Client)
+-------+-------+
| ONE connection
v
+---------------+
| MCP-RLM | <-- THIS MIDDLEWARE
| Proxy | - Connects to N servers
| | - Auto-truncates large responses
| | - Caches + provides proxy_filter / proxy_search / proxy_explore
| | - Tracks token savings
+-------+-------+
| Manages connections to your servers
+---+----+--------+--------+
v v v v
+-----+ +-----+ +-----+ +-----+
| FS | | Git | | API | | DB | <-- Your existing servers
+-----+ +-----+ +-----+ +-----+ (NO changes needed!)
```
### Benefits
- **Zero Friction**: Works with existing MCP servers (no code changes)
- **Huge Token Savings**: 85-95% reduction typical
- **Multi-Server**: Aggregate tools from many servers through one interface
- **Clean Schemas**: No `_meta` injection; tool schemas are passed through unmodified
- **Agent-Friendly**: Three first-class proxy tools with flat, simple parameters. `proxy_filter` uses Python REPL for flexible programmatic transformations
- **Auto-Truncation**: Large responses automatically truncated + cached for follow-up
- **Multi-Agent Ready**: Per-agent cache isolation supports hundreds of concurrent agents
- **Production Ready**: Connection pooling, error handling, metrics, TTL-based caching, memory-aware eviction
---
## How It Works
### Architecture Overview
1. **Client connects to proxy** (instead of individual servers)
2. **Proxy connects to N servers** (configured in `mcp.json`)
3. **Tools are aggregated** with server prefixes (`filesystem_read_file`)
4. **Tool schemas pass through clean** - no modification, no `_meta` injection
5. **Large responses are auto-truncated** and cached with a `cache_id`
6. **Three proxy tools** let agents drill into cached data without re-executing
### The Proxy Tools
| Tool | Purpose | Key Parameters |
|------|---------|----------------|
| `proxy_filter` | Transform/filter using Python REPL | `cache_id`, `code` (required), `return_format` |
| `proxy_search` | Grep/BM25/fuzzy/context search on cached or fresh result | `cache_id`, `pattern`, `mode`, `max_results` |
| `proxy_explore` | Discover data structure without loading content | `cache_id`, `max_depth` |
All parameters are **flat, top-level, simple types** - no nested objects required. Each tool can work in two modes:
- **Cached mode**: pass `cache_id` from a previous truncated response
- **Fresh mode**: pass `tool` + `arguments` to call and filter in one step
### Typical Agent Workflow
```
Step 1: Agent calls filesystem_read_file(path="large-data.json")
-> Response is 50,000 chars -> auto-truncated + cached
-> Agent receives first 8,000 chars + cache_id="a1b2c3d4e5f6"
Step 2: Agent calls proxy_explore(cache_id="a1b2c3d4e5f6")
-> Returns structure summary: types, field names, sizes, sample
-> 200 tokens instead of 50,000
Step 3: Agent calls proxy_filter(cache_id="a1b2c3d4e5f6", code="[{k: item[k] for k in ['name', 'email']} for item in data]")
-> Returns only projected fields using Python REPL
-> 500 tokens instead of 50,000
Step 4: Agent calls proxy_search(cache_id="a1b2c3d4e5f6", pattern="error", mode="bm25", top_k=3)
-> Returns top-3 most relevant chunks
-> 800 tokens instead of 50,000
Total: ~1,500 tokens vs 50,000+ (97% savings!)
```
---
## Token Savings Impact
### Real-World Token Reduction Examples
| Use Case | Without Proxy | With Proxy | Savings | Cost Impact* |
|----------|---------------|------------|---------|--------------|
| **User Profile API** | 2,500 tokens | 150 tokens | **94%** | $0.10 -> $0.006 |
| **Log File Search** (1MB) | 280,000 tokens | 800 tokens | **99.7%** | Rate limited -> $0.32 |
| **Database Query** (100 rows) | 15,000 tokens | 1,200 tokens | **92%** | $0.60 -> $0.048 |
| **File System Scan** | 8,000 tokens | 400 tokens | **95%** | $0.32 -> $0.016 |
\* Estimated using GPT-4 pricing ($0.03/1K input tokens)
### Compound Savings in Multi-Step Workflows
For a typical AI agent workflow with 10 tool calls:
- **Without proxy**: 10 calls x 10,000 tokens avg = **100,000 tokens** -> $3.00
- **With proxy**: 10 calls x 800 tokens avg = **8,000 tokens** -> $0.24
- **Total savings per workflow**: **$2.76 (92% reduction)**
---
## Proxy Tool Reference
### proxy_filter
Transform/filter cached or fresh tool results using Python REPL. Execute Python code to programmatically transform data. The cached data is available as variable `data` in a sandboxed Python environment.
**Simple field projection:**
```json
{
"cache_id": "a1b2c3d4e5f6",
"code": "[{k: item[k] for k in ['name', 'email']} for item in data]"
}
```
**Complex filtering with conditions:**
```json
{
"cache_id": "a1b2c3d4e5f6",
"code": "[item for item in data if item.get('status') == 'active' and item.get('score', 0) > 80]"
}
```
**Aggregation:**
```json
{
"cache_id": "a1b2c3d4e5f6",
"code": "{'total': len(data), 'avg_score': sum(item.get('score', 0) for item in data) / len(data) if data else 0}"
}
```
**With return format:**
```json
{
"cache_id": "a1b2c3d4e5f6",
"code": "[{'name': item['name'], 'email': item['email']} for item in data]",
"return_format": "json"
}
```
**With fresh call:**
```json
{
"tool": "filesystem_read_file",
"arguments": {"path": "data.json"},
"code": "[item['name'] for item in data]"
}
```
### proxy_search
Search within a cached or fresh result. Modes: `regex`, `bm25`, `fuzzy`, `context`.
```json
{
"cache_id": "a1b2c3d4e5f6",
"pattern": "ERROR|FATAL",
"mode": "regex",
"case_insensitive": true,
"max_results": 20,
"context_lines": 2
}
```
BM25 relevance search:
```json
{
"cache_id": "a1b2c3d4e5f6",
"pattern": "database connection timeout",
"mode": "bm25",
"top_k": 5
}
```
### proxy_explore
Discover the structure of data without loading it all.
```json
{
"cache_id": "a1b2c3d4e5f6",
"max_depth": 3
}
```
Returns: types, field names, sizes, and a small sample.
---
## Multi-Agent Support
The proxy is designed to handle hundreds of concurrent agents efficiently through **per-agent cache isolation**.
### How It Works
When `enableAgentIsolation` is enabled (default), each agent gets:
- **Dedicated cache quota**: 20 entries and 100MB memory per agent (configurable)
- **Isolated cache space**: One agent's cache doesn't affect others
- **Smart eviction**: Large, idle, rarely-accessed entries evicted first
- **Automatic agent management**: LRU eviction of agent caches when max agents reached
### Benefits for Multi-Agent Scenarios
| Scenario | Without Isolation | With Isolation |
|----------|------------------|----------------|
| **100 agents, shared cache (50 entries)** | ~0.5 entries/agent, 10-20% hit rate | N/A |
| **100 agents, per-agent isolation (20 entries)** | N/A | 20 entries/agent, 70-80% hit rate |
| **Cache thrashing** | High (agents evict each other's entries) | None (isolated caches) |
| **Memory usage** | Unbounded risk | Predictable (~2GB for 100 agents) |
| **Performance** | Degrades with more agents | Consistent per agent |
### Configuration for Multi-Agent
```json
{
"proxySettings": {
"enableAgentIsolation": true,
"maxEntriesPerAgent": 20,
"maxMemoryPerAgent": 104857600,
"maxTotalAgents": 1000,
"cacheTTLSeconds": 600
}
}
```
**Settings:**
- `enableAgentIsolation`: Enable per-agent cache isolation (recommended for 10+ agents)
- `maxEntriesPerAgent`: Maximum cache entries per agent (default: 20)
- `maxMemoryPerAgent`: Maximum memory per agent in bytes (default: 100MB)
- `maxTotalAgents`: Maximum concurrent agent caches (default: 1000)
### Cache ID Format
With agent isolation enabled, cache IDs are prefixed with the agent identifier:
- Format: `{agent_id}:{cache_id}`
- Example: `agent_1:abc123def456`
- The proxy automatically handles agent ID extraction and prefixing
### Backward Compatibility
If `enableAgentIsolation` is `false`, the proxy uses a shared cache (backward compatible with single-agent deployments).
---
## Configuration
### mcp.json
```json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
},
"git": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-git", "/repo"]
}
},
"proxySettings": {
"maxResponseSize": 8000,
"cacheMaxEntries": 50,
"cacheTTLSeconds": 300,
"enableAutoTruncation": true,
"enableAgentIsolation": true,
"maxEntriesPerAgent": 20,
"maxMemoryPerAgent": 104857600,
"maxTotalAgents": 1000
}
}
```
### Proxy Settings
| Setting | Default | Description |
|---------|---------|-------------|
| `maxResponseSize` | 8000 | Character threshold for auto-truncation |
| `cacheMaxEntries` | 50 | Maximum cached responses (per agent if isolation enabled) |
| `cacheTTLSeconds` | 300 | Cache entry time-to-live (seconds) |
| `enableAutoTruncation` | true | Enable/disable auto-truncation + caching |
| `enableAgentIsolation` | true | Enable per-agent cache isolation (recommended for multi-agent) |
| `maxEntriesPerAgent` | 20 | Maximum cache entries per agent (when isolation enabled) |
| `maxMemoryPerAgent` | 104857600 | Maximum memory per agent in bytes (100MB default) |
| `maxTotalAgents` | 1000 | Maximum concurrent agent caches |
---
## Installation
```bash
pip install mcp-rlm-proxy
# For development:
# git clone https://github.com/pratikjadhav2726/mcp-rlm-proxy.git && cd mcp-rlm-proxy && uv sync
```
### Running the Proxy
```bash
mcp-rlm-proxy --config ./mcp.json
```
### Using with Claude Desktop
Edit your Claude Desktop config:
```json
{
"mcpServers": {
"proxy": {
"command": "mcp-rlm-proxy",
"args": ["--config", "/absolute/path/to/mcp.json"]
}
}
}
```
### Using Programmatically
```python
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
server_params = StdioServerParameters(
command="mcp-rlm-proxy",
args=["--config", "/absolute/path/to/mcp.json"]
)
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
# List tools (prefixed with server names + 3 proxy tools)
tools = await session.list_tools()
# Call a tool - if response is large, it's auto-truncated with cache_id
result = await session.call_tool("filesystem_read_file", {
"path": "large-data.json"
})
# Drill into the cached data
filtered = await session.call_tool("proxy_filter", {
"cache_id": "a1b2c3d4e5f6",
"fields": ["users.name", "users.email"]
})
```
---
## Legacy _meta Support
For backward compatibility, the `_meta` parameter is still accepted in tool arguments but is no longer advertised in schemas. If you pass `_meta.projection` or `_meta.grep`, the proxy will apply them. However, the recommended approach is to use the proxy tools instead:
| Old way (_meta) | New way (proxy tools) |
|-----------------|----------------------|
| Hidden in nested `_meta.projection` | `proxy_filter(fields=["name"])` |
| Hidden in nested `_meta.grep` | `proxy_search(pattern="ERROR")` |
| Not discoverable by agents | First-class tools visible in `list_tools()` |
---
## Search Modes
| Mode | Use When | Token Savings |
|------|----------|---------------|
| `structure` (proxy_explore) | Don't know data format | 99.9%+ |
| `bm25` | Know what, not where | 99%+ |
| `fuzzy` | Handle typos/variations | 98%+ |
| `context` | Need full paragraphs | 95%+ |
| `regex` | Know exact pattern | 95%+ |
---
## Performance Monitoring
Automatic tracking of token savings and performance:
```
INFO: Token savings: 50,000 -> 500 tokens (99.0% reduction)
=== Proxy Performance Summary ===
Total calls: 127
Projection calls: 45
Grep calls: 23
Auto-truncated: 15
Original tokens: 2,450,000
Filtered tokens: 125,000
Tokens saved: 2,325,000
Savings: 94.9%
Active connections: 3
```
### Cache Statistics (Multi-Agent)
With agent isolation enabled, you can monitor per-agent cache usage:
```python
# Get aggregate cache statistics
stats = await proxy_server.cache.stats()
# Returns:
# {
# "total_agents": 42,
# "total_entries": 840,
# "total_cached_bytes": 52428800,
# "max_agents": 1000,
# "max_entries_per_agent": 20,
# "max_memory_per_agent": 104857600,
# "agents": [
# {
# "agent_id": "agent_1",
# "entries": 15,
# "memory_bytes": 3145728,
# "last_accessed_at": 1234567890.123
# },
# ...
# ]
# }
# Get statistics for a specific agent
agent_stats = await proxy_server.cache.stats(agent_id="agent_1")
```
---
## Comparison with RLM Paper Concepts
| RLM Paper Concept | MCP-RLM-Proxy Implementation |
|-------------------|------------------------------|
| **External Environment** | Tool outputs treated as inspectable data stores |
| **Recursive Decomposition** | proxy_explore -> proxy_filter -> proxy_search workflow |
| **Programmatic Exploration** | proxy_search with multiple modes |
| **Snippet Processing** | Auto-truncation + cached follow-up |
| **Cost Efficiency** | 85-95% token reduction vs. full context loading |
| **Long Context Handling** | Processes multi-MB tool outputs without context limits |
---
## Documentation
- **[Architecture](docs/ARCHITECTURE.md)** - System design and data flow
- **[Configuration](docs/CONFIGURATION.md)** - Configuration options and validation
- **[Performance](docs/PERFORMANCE.md)** - Performance benchmarks and optimization
---
## Related Concepts
- **Recursive Language Models Paper**: [arXiv:2512.24601](https://arxiv.org/abs/2512.24601)
- **Model Context Protocol**: [MCP Specification](https://github.com/modelcontextprotocol)
---
## Contributing
See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and guidelines.
## License
MIT License - see [LICENSE](LICENSE)
---
**Built for the AI agent community**
| text/markdown | MCP-RLM-Proxy Contributors | null | null | null | MIT | ai, llm, mcp, model-context-protocol, proxy | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Topic :: Internet :: WWW/HTTP :: HTTP Servers",
"Topic :: Software ... | [] | null | null | >=3.12 | [] | [] | [] | [
"mcp>=1.23.1",
"pydantic>=2.0.0",
"pytest-asyncio>=0.21.0; extra == \"dev\"",
"pytest>=7.4.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/pratikjadhav2726/mcp-rlm-proxy",
"Documentation, https://github.com/pratikjadhav2726/mcp-rlm-proxy#readme",
"Repository, https://github.com/pratikjadhav2726/mcp-rlm-proxy",
"Issues, https://github.com/pratikjadhav2726/mcp-rlm-proxy/issues"
] | uv/0.9.2 | 2026-02-18T10:10:20.275034 | mcp_rlm_proxy-0.1.1.tar.gz | 126,679 | b0/3b/6b09fa8b4e52e5e1e494f50776b6c9b6346c3b7e5a979dc4ef47dc06ac02/mcp_rlm_proxy-0.1.1.tar.gz | source | sdist | null | false | fbf355e6e45d5168ebf6d88776dfdb48 | b144e320f54916f0d5d6ebb7407bd3fa6266680605e85107117c9761c9406b4d | b03b6b09fa8b4e52e5e1e494f50776b6c9b6346c3b7e5a979dc4ef47dc06ac02 | null | [
"LICENSE"
] | 272 |
2.4 | cyberwave | 0.3.14 | Python SDK for Cyberwave | # Cyberwave Python SDK
The official Python SDK for Cyberwave. Create, control, and simulate robotics with ease.
## Status
[](https://pypi.org/project/cyberwave/)
[](https://pypi.org/project/cyberwave/)
[](https://github.com/cyberwave-os/cyberwave-python/actions/workflows/test.yml)
[](https://github.com/cyberwave-os/cyberwave-python/actions/workflows/test.yml)
[](https://github.com/cyberwave-os/cyberwave-python/actions/workflows/test.yml)
[](https://github.com/cyberwave-os/cyberwave-python/actions/workflows/test.yml)
[](https://github.com/cyberwave-os/cyberwave-python/actions/workflows/test.yml)
## Installation
```bash
pip install cyberwave
```
## Quick Start
### 1. Get Your Token
Get your API token from the Cyberwave platform:
- Log in to your Cyberwave instance
- Navigate to [Profile](https://cyberwave.com/profile) → API Tokens
- Create a token and copy it
### 2. Create Your First Digital Twin
```python
from cyberwave import Cyberwave
# Configure with your token
cw = Cyberwave(
token="your_token_here",
)
# Create a digital twin from an asset
robot = cw.twin("the-robot-studio/so101")
# Change position and rotation in the environemtn
robot.edit_positon(x=1.0, y=0.0, z=0.5)
robot.edit_rotation(yaw=90) # degrees
# Move the robot arm to 30 degrees
robot.joints.set("1", 30)
# Get current joint positions
print(robot.joints.get_all())
```
## Core Features
### Working with Workspaces and Projects
```python
from cyberwave import Cyberwave
cw = Cyberwave(
token="your_token_here"
)
# You can also set your token as an environment variable: export CYBERWAVE_TOKEN=your_token_here
# in that case, you can simply do:
cw = Cyberwave()
# List workspaces
workspaces = cw.workspaces.list()
print(f"Found {len(workspaces)} workspaces")
# Create a project
project = cw.projects.create(
name="My Robotics Project",
workspace_id=workspaces[0].uuid
)
# Create an environment
environment = cw.environments.create(
name="Development",
project_id=project.uuid
)
```
### Managing Assets and Twins
```python
# To instantiate a twin, you can query the available assets from the catalog.
# This query will return both the public assets availaable at cyberwave.com/catalog and the private assets available to your organization.
assets = cw.assets.search("so101")
robot = cw.twin(assets[0].registry_id) # the registry_id is the unique identifier for the asset in the catalog. in this case it's the-robot-studio/so101
# Edit the twin to a specific position
robot.edit_position([1.0, 0.5, 0.0])
# Update scale
robot.edit_scale(x=1.5, y=1.5, z=1.5)
# Move a joint to a specific position using radians
robot.joints.set("shoulder_joint", math.pi/4)
# You can also use degrees:
robot.joints.set("shoulder_joint", 45, degrees=True)
# You can also go a get_or_create for a specific twin an environment you created:
robot = cw.twin("the-robot-studio/so101", environment_id="YOUR_ENVIRONMENT_ID")
```
### Environment Variables
If you are always using the same environment, you can set it as a default with the CYBERWAVE_ENVIRONMENT_ID environment variable:
```bash
export CYBERWAVE_ENVIRONMENT_ID="YOUR_ENVIRONMENT_ID"
export CYBERWAVE_TOKEN="YOUR_TOKEN"
python your_script.py
```
And then you can simply do:
```python
from cyberwave import Cyberwave
cw = Cyberwave()
robot = cw.twin("the-robot-studio/so101")
```
This code will return you the first SO101 twin in your environment, or create it if it doesn't exist.
### Video Streaming (WebRTC)
Stream camera feeds to your digital twins using WebRTC. The SDK supports both standard USB/webcam cameras (via OpenCV) and Intel RealSense cameras with RGB and depth streaming.
#### Prerequisites
Install FFMPEG if you don't have it:
```bash
# Mac
brew install ffmpeg pkg-config
# Ubuntu
sudo apt-get install ffmpeg
```
Install camera dependencies:
```bash
# Standard cameras (OpenCV)
pip install cyberwave[camera]
# Intel RealSense cameras
pip install cyberwave[realsense]
```
> **📌 Note for ARM64/Raspberry Pi**: The `pip install cyberwave[realsense]` command installs the Python wrapper, but you'll still need the librealsense SDK installed on your system. On x86_64 systems, you can install it via `sudo apt install librealsense2` or use pre-built wheels. **On Raspberry Pi OS (ARM64), you must build librealsense from source** - see our [Raspberry Pi Installation Guide](install_realsense_raspian_os.md).
#### Quick Start
```python
import asyncio
import os
from cyberwave import Cyberwave
cw = Cyberwave()
camera = cw.twin("cyberwave/standard-cam")
try:
print(f"Streaming to twin {camera.uuid}... (Ctrl+C to stop)")
await camera.start_streaming()
while True:
await asyncio.sleep(1)
except (KeyboardInterrupt, asyncio.CancelledError):
print("\nStopping...")
finally:
await camera.stop_streaming()
cw.disconnect()
```
If you have a depth camera - that streams also a point cloud - it's the same thing! You just change the twin name and Cyberwave takes care of the rest:
```python
import asyncio
import os
from cyberwave import Cyberwave
cw = Cyberwave()
camera = cw.twin("intel/realsensed455")
try:
print(f"Streaming to twin {camera.uuid}... (Ctrl+C to stop)")
await camera.start_streaming()
while True:
await asyncio.sleep(1)
except (KeyboardInterrupt, asyncio.CancelledError):
print("\nStopping...")
finally:
await camera.stop_streaming()
cw.disconnect()
```
## Examples
Check the [examples](examples) directory for complete examples:
- Basic twin control
- Multi-robot coordination
- Real-time synchronization
- Joint manipulation for robot arms
## Advanced Usage
### Joint Control
You can change a specific joint actuation. You can use degrees or radiants:
```python
robot = cw.twin("the-robot-studio/so101")
# Set individual joints (degrees by default)
robot.joints.set("shoulder_joint", 45, degrees=True)
# Or use radians
import math
robot.joints.set("elbow_joint", math.pi/4, degrees=False)
# Get current joint position
angle = robot.joints.get("shoulder_joint")
# List all joints
joint_names = robot.joints.list()
# Get all joint states at once
all_joints = robot.joints.get_all()
```
To check out the available endpoints and their parameters, you can refer to the full API reference [here](https://docs.cyberwave.com/api-reference/overview).
### Changing data source
By default, the SDK will send data marked as arriving from the real world. If you want to send data from a simulated environment using the SDK, you can initialize the SDK as follows:
```python
from cyberwave import Cyberwave
cw = Cyberwave(source_type="sim")
```
You can also use the SDK as a client of the Studio editor - making it appear as if it was just another editor on the web app. To do so, you can initialize it as follows:
```python
from cyberwave import Cyberwave
cw = Cyberwave(source_type="edit")
```
Lastly, if you want to have your SDK act as a remote teleoperator, sending commands to the actual device from the cloud, you can init the SDK as follows:
```python
from cyberwave import Cyberwave
cw = Cyberwave(source_type="tele")
```
### Camera & Sensor discovery
You can leverage the SDK to discover the CV2 (standard webcameras) attached to your device:
```python
from cyberwave.sensor import CV2VideoTrack, CV2CameraStreamer, CameraConfig, Resolution
# Check supported resolutions for a camera
supported = CV2VideoTrack.get_supported_resolutions(camera_id=0)
print(f"Supported: {[str(r) for r in supported]}")
# Get camera info
info = CV2VideoTrack.get_camera_info(camera_id=0)
print(f"Camera: {info}")
# Using CameraConfig
config = CameraConfig(resolution=Resolution.HD, fps=30, camera_id=0)
streamer = CV2CameraStreamer.from_config(cw.mqtt, config, twin_uuid="...")
```
### RealSense Camera (RGB + Depth)
You can also discover and set up RGD+D (Depth) cameras.
> **⚠️ Raspberry Pi / ARM64 Users**: If you're running on Raspberry Pi OS or other ARM64 systems, you'll need to manually build librealsense from source, as pre-built packages aren't available. See our [Raspberry Pi Installation Guide](install_realsense_raspian_os.md) for detailed instructions.
The SDK supports dynamic discovery of RealSense device capabilities:
```python
from cyberwave.sensor import (
RealSenseDiscovery,
RealSenseConfig,
RealSenseStreamer,
Resolution
)
# Check if RealSense SDK is available
if RealSenseDiscovery.is_available():
# List connected devices
devices = RealSenseDiscovery.list_devices()
for dev in devices:
print(f"{dev.name} (SN: {dev.serial_number})")
# Get detailed device info with all supported profiles
info = RealSenseDiscovery.get_device_info()
print(f"Color resolutions: {info.get_color_resolutions()}")
print(f"Depth resolutions: {info.get_depth_resolutions()}")
print(f"Sensor options: {info.sensor_options}")
# Auto-detect and create streamer from device capabilities
streamer = RealSenseStreamer.from_device(
cw.mqtt,
prefer_resolution=Resolution.HD,
prefer_fps=30,
enable_depth=True,
twin_uuid="your_twin_uuid"
)
# Or use manual configuration with validation
config = RealSenseConfig(
color_resolution=Resolution.HD,
depth_resolution=Resolution.VGA,
color_fps=30,
depth_fps=15,
enable_depth=True
)
# Validate against device
is_valid, errors = config.validate()
if not is_valid:
print(f"Config errors: {errors}")
streamer = RealSenseStreamer.from_config(cw.mqtt, config, twin_uuid="...")
```
#### RealSense Device Discovery
Query detailed device capabilities:
```python
info = RealSenseDiscovery.get_device_info()
# Check if a specific profile is supported
if info.supports_color_profile(1280, 720, 30, "BGR8"):
print("HD @ 30fps with BGR8 is supported")
# Get available FPS for a resolution
fps_options = info.get_color_fps_options(1280, 720)
print(f"Available FPS for HD: {fps_options}")
# Get sensor options (exposure, gain, laser power, etc.)
for sensor_name, options in info.sensor_options.items():
print(f"\n{sensor_name}:")
for opt in options:
print(f" {opt.name}: {opt.value} (range: {opt.min_value}-{opt.max_value})")
```
### Edge Management
Edges are physical devices (e.g. Raspberry Pi, Jetson) that run the Cyberwave Edge Core. You can manage them programmatically via `cw.edges`.
```python
from cyberwave import Cyberwave
cw = Cyberwave()
# List all edges registered to your account
edges = cw.edges.list()
for edge in edges:
print(edge.uuid, edge.name, edge.fingerprint)
# Get a specific edge
edge = cw.edges.get("your-edge-uuid")
# Register a new edge with a hardware fingerprint
edge = cw.edges.create(
fingerprint="linux-a1b2c3d4e5f60000", # stable hardware identifier
name="lab-rpi-001", # optional human-readable name
workspace_id="your-workspace-uuid", # optional, scopes the edge to a workspace
metadata={"location": "lab-shelf-2"}, # optional arbitrary metadata
)
# Update edge name or metadata
edge = cw.edges.update(edge.uuid, {"name": "lab-rpi-001-renamed"})
# Delete an edge
cw.edges.delete(edge.uuid)
```
The fingerprint is a stable identifier derived from the host hardware (hostname, OS, architecture, and MAC address). The Edge Core generates and persists it automatically on first boot at `/etc/cyberwave/fingerprint.json`. When a twin has `metadata.edge_fingerprint` set to the same value, the Edge Core will automatically pull and start its driver container on boot.
### Alerts
Create, list, and manage alerts directly from a twin. Alerts notify operators that action is needed (e.g. a robot needs calibration or a sensor reading is out of range).
```python
twin = cw.twin(twin_id="your_twin_uuid")
# Create an alert
alert = twin.alerts.create(
name="Calibration needed",
description="Joint 3 is drifting beyond tolerance",
severity="warning", # info | warning | error | critical
alert_type="calibration_needed",
source_type="edge", # edge | cloud | workflow
)
# List active alerts for this twin
for a in twin.alerts.list(status="active"):
print(a.name, a.severity, a.status)
# Lifecycle actions
alert.acknowledge() # operator has seen it
alert.resolve() # root cause addressed
# Other operations
alert.silence() # suppress without resolving
alert.update(severity="critical")
alert.delete()
```
## Testing
### Unit Tests
Run basic import tests:
```bash
poetry install
poetry run python tests/test_imports.py
```
## Support
- **Documentation**: [docs.cyberwave.com](https://docs.cyberwave.com)
- **Issues**: [GitHub Issues](https://github.com/cyberwave/cyberwave-python/issues)
- **Community**: [Discord](https://discord.gg/dfGhNrawyF)
| text/markdown | Simone Di Somma | sdisomma@cyberwave.com | null | null | null | null | [
"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 | [] | [] | [] | [
"aiortc<2.0.0,>=1.5.0; extra == \"camera\" or extra == \"realsense\"",
"av<17.0.0,>=16.0.1; extra == \"camera\" or extra == \"realsense\"",
"numpy<2.0.0,>=1.26.0",
"opencv-python<5.0.0,>=4.8.0; extra == \"camera\" or extra == \"realsense\"",
"paho-mqtt<3.0.0,>=2.1.0",
"pydantic<3,>=2",
"python-dateutil<... | [] | [] | [] | [] | poetry/2.3.2 CPython/3.10.19 Linux/6.14.0-1017-azure | 2026-02-18T10:10:19.359396 | cyberwave-0.3.14-py3-none-any.whl | 572,582 | 4a/4c/db0afdfd1005cb43e1ae57bd46d6fb3ddb9456b77d233d0de739ce24b295/cyberwave-0.3.14-py3-none-any.whl | py3 | bdist_wheel | null | false | 71d194ddf526a9b431e95f7f51fb6be2 | 5bba1fa12e22e36e4809bad5ba7eb77dd4dc08e4fa067f638e0c28f864089792 | 4a4cdb0afdfd1005cb43e1ae57bd46d6fb3ddb9456b77d233d0de739ce24b295 | null | [
"LICENSE"
] | 1,168 |
2.4 | nebius | 0.3.37 | Nebius Python SDK | # Nebius Python® SDK
The **Nebius Python® SDK** is a comprehensive client library for interacting with [nebius.com](https://nebius.com) services.
Built on gRPC, it supports all APIs defined in the [Nebius API repository](https://github.com/nebius/api).
This SDK simplifies resource management, authentication, and communication with Nebius services, making it a valuable tool for developers.
> **Note**: "Python" and the Python logos are trademarks or registered trademarks of the Python Software Foundation, used by Nebius B.V. with permission from the Foundation.
### Full documentation and reference
To see all the services and their methods, look into the [API reference](https://nebius.github.io/pysdk/apiReference.html).
### Installation
```bash
pip install nebius
```
If you've received this module in a zip archive or checked out from git, install it as follows:
```bash
pip install ./path/to/your/pysdk
```
### Migration from 0.2.x to 0.3.x
In version 0.3.0, we introduced a small breaking change aimed at improving the authorization process:
- Moved authorization options to direct request argument
- Removed `nebius.aio.authorization.options.options_to_metadata`
- Removed metadata cleanup, as it is not used
`<= 0.2.74`:
```python
from nebius.aio.authorization.options import options_to_metadata
service.request(
req,
metadata=({'your':'metadata'}).update(options_to_metadata(
{
OPTION_RENEW_REQUIRED: "true",
OPTION_RENEW_SYNCHRONOUS: "true",
OPTION_RENEW_REQUEST_TIMEOUT: ".9",
}
))
)
```
`>= 0.3.0`:
```python
service.request(
req,
metadata={'your':'metadata'},
auth_options={
OPTION_RENEW_REQUIRED: "true",
OPTION_RENEW_SYNCHRONOUS: "true",
OPTION_RENEW_REQUEST_TIMEOUT: ".9",
}
)
```
### Example
Working examples in `src/examples`.
Try it out as follows:
```bash
NEBIUS_IAM_TOKEN=$(nebius iam get-access-token) python -m ./path/to/your/pysdk/src/examples/basic.py your-project-id
```
### How-to
#### Initialize
```python
from nebius.sdk import SDK
sdk = SDK()
```
This will initialize the [SDK](https://nebius.github.io/pysdk/nebius.sdk.SDK.html) with an IAM token from a `NEBIUS_IAM_TOKEN` env var.
If you want to use different ways of authorization, read further.
See the following how-to's on how to provide your crerentials:
##### Initialize using an IAM Token
You can also initialize the `SDK` by providing the token directly or from the other environment variable, here are examples how to do that:
```python
import os
from nebius.sdk import SDK
from nebius.aio.token.static import Bearer, EnvBearer # [1]
from nebius.aio.token.token import Token # [2]
sdk = SDK(credentials=os.environ.get("NEBIUS_IAM_TOKEN", ""))
#or
sdk = SDK(credentials=Bearer(os.environ.get("NEBIUS_IAM_TOKEN", "")))
#or
sdk = SDK(credentials=EnvBearer("NEBIUS_IAM_TOKEN"))
#or
sdk = SDK(credentials=Bearer(Token(os.environ.get("NEBIUS_IAM_TOKEN", ""))))
```
[[1](https://nebius.github.io/pysdk/nebius.aio.token.static.html), [2](https://nebius.github.io/pysdk/nebius.aio.token.token.html)]
Now, your application will get token from the local Env variable, as in the example above, but provided in several other ways.
##### Initialize using CLI config
If you've set up [Nebius AI Cloud CLI](https://docs.nebius.com/cli), you can initialize the `SDK` using [CLI config](https://nebius.github.io/pysdk/nebius.aio.cli_config.Config.html):
```python
from nebius.sdk import SDK
from nebius.aio.cli_config import Config
sdk = SDK(config_reader=Config())
```
This will also import the domain if the endpoint parameter is in the config and the domain wasn't set explicitly.
*Keep in mind, that it will get the token from the `NEBIUS_IAM_TOKEN` environment variable if it is set, or use `NEBIUS_PROFILE` for selecting the profile, the same way CLI does. To stop that from happening, set `Config(no_env=True)`*
Config reader also helps with getting the default parent ID if necessary:
```python
from nebius.aio.cli_config import Config
print(f"My default parent ID: {Config().parent_id}")
```
Check the [`Config` documentation](https://nebius.github.io/pysdk/nebius.aio.cli_config.Config.html) for more settings like file path, profile name or environment variables names.
##### Initialize with the private key file
If you have a private key and a service account, you may want to authorize using them. Here is an example of how to do it.
Replace in the IDs in the following example with your service account and public key ID pair, related to the private key you have.
You need to have a `private_key.pem` file on your machine, modify the file path in the example accordingly.
```python
from nebius.sdk import SDK
from nebius.base.service_account.pk_file import Reader as PKReader # [1]
sdk = SDK(
credentials=PKReader(
filename="location/of/your/private_key.pem",
public_key_id="public-key-id",
service_account_id="your-service-account-id",
),
)
#or without importing PKReader:
sdk = SDK(
service_account_private_key_file_name="location/of/your/private_key.pem",
service_account_public_key_id="public-key-id",
service_account_id="your-service-account-id",
)
```
[[1](https://nebius.github.io/pysdk/nebius.base.service_account.pk_file.Reader.html)]
##### Initialize with a credentials file
Assuming you have a joint credentials file with a private key and all the IDs inside.
```python
from nebius.sdk import SDK
from nebius.base.service_account.credentials_file import Reader as CredentialsReader # [1]
sdk = SDK(
credentials=CredentialsReader(
filename="location/of/your/credentials.json",
),
)
#or without importing CredentialsReader:
sdk = SDK(
credentials_file_name="location/of/your/credentials.json",
)
```
[[1](https://nebius.github.io/pysdk/nebius.base.service_account.credentials_file.Reader.html)]
#### Test the SDK
Now as you've initialized the SDK, you may want to test whether your credentials are ok, everything works and you have a good connection.
To test the SDK, we provide a convenient method [`SDK.whoami`](https://nebius.github.io/pysdk/nebius.sdk.SDK.html#whoami), that will return the basic information about the profile, you've authenticated with:
```python
import asyncio
async def my_call():
async with sdk:
print(await sdk.whoami())
asyncio.run(my_call())
```
It is important to close the SDK, so all the coroutines and tasks will be gracefully stopped and gathered. It can either be achieved by using `async with`, or by explicitly calling `sdk.close()`:
```python
import asyncio
async def my_call():
try:
print(await sdk.whoami())
# Other calls to SDK
finally:
await sdk.close()
asyncio.run(my_call())
```
SDK is created with asyncio in mind, so the best way to call methods of it is to use an async context. But if you haven't started async loop, you can run it synchronously:
```python
try:
print(sdk.whoami().wait())
# Other calls to SDK
finally:
sdk.sync_close()
```
*Keep in mind, that this may lead to some problems or infinite locks, even if timeouts have been added. Moreover, synchronous methods won't run inside an async call stack, if you haven't provided a dedicated separate loop for the SDK. And even when the loop is provided, there might be issues or deadlocks.*
Closing the SDK is not strictly necessary, but forgetting to add it may lead to a bunch of annoying errors of unterminated tasks.
#### Test token renewal
If you use service account, credentials file or something like that, SDK will renew your tokens under the hood. This renewal process will normally report to log if any errors occur. However it might be good to get the repored errors as request errors. In that case, pass special options to the request like so:
```python
import asyncio
from nebius.aio.token.renewable import (
OPTION_RENEW_REQUEST_TIMEOUT,
OPTION_RENEW_REQUIRED,
OPTION_RENEW_SYNCHRONOUS,
)
async def my_call():
try:
await sdk.whoami(
auth_options={
OPTION_RENEW_REQUIRED: "true",
OPTION_RENEW_SYNCHRONOUS: "true",
OPTION_RENEW_REQUEST_TIMEOUT: ".9",
}
)
except Exception as err:
print(f"something is wrong with your token: {err=}")
finally:
await sdk.close()
asyncio.run(my_call())
```
You can pass these options to any request.
The overall time spent trying to authenticate/renew before making the call is bounded by `auth_timeout` (default 15 minutes). You can adjust it per-call, for example: `await sdk.whoami(auth_timeout=600.0)`. Setting `auth_timeout=None` removes this bound but may cause the call to wait indefinitely if renewal cannot complete.
#### Call some method
Now as you have your SDK initialized and tested, you may work with our services and call their methods with it. Here and further we assume, that the [SDK](https://nebius.github.io/pysdk/nebius.sdk.SDK.html) is initialized and is located in the `sdk` variable. We also omit closing the SDK.
All the services API classes are located in submodules of `nebius.api.nebius`. [The reference can be found here](https://nebius.github.io/pysdk/apiReference.html). The `nebius.api.nebius` also includes all the raw gRPC and ProtoBuf classes.
As an example how to use the API, let's receive a bucket from a storage service by its ID:
```python
import asyncio
from nebius.api.nebius.storage.v1 import GetBucketRequest
from nebius.api.nebius.storage.v1 import BucketServiceClient
async def my_call():
service = BucketServiceClient(sdk)
return await service.get(GetBucketRequest(
id="some-bucket-id",
))
asyncio.run(my_call())
```
Same thing, but synchronously:
```python
import asyncio
from nebius.api.nebius.storage.v1 import BucketServiceClient, GetBucketRequest
service = BucketServiceClient(sdk)
result = service.get(GetBucketRequest(
id="some-bucket-id",
)).wait()
```
##### Parent ID
Some methods may include `parent_id` in the requests, for certain methods this field is populated automatically:
* Methods `list` and `get_by_name` with an empty `parent_id`
* All other methods, except `update`, with an empty `metadata.parent_id`
The `parent_id` will only be set if it was preset at the initialization, either from the [CLI `Config`](https://nebius.github.io/pysdk/nebius.aio.cli_config.Config.html) or from the `parent_id` attribute from the [SDK](https://nebius.github.io/pysdk/nebius.sdk.SDK.html). You can disable it, retaining the CLI Config, if you set it up with `no_parent_id=True`.
##### Operations
Many core methods return a [`nebius.aio.Operation`](https://nebius.github.io/pysdk/nebius.aio.operation.Operation.html) object, representing a time-consuming asynchronous operation. For example, the `create` request from the `BucketServiceClient` above is one of such cases. The [`nebius.aio.Operation`](https://nebius.github.io/pysdk/nebius.aio.operation.Operation.html) is a wrapper class that provides convenient methods for working with operations. It can be awaited util completion.
Here is an async example:
```python
from nebius.api.nebius.storage.v1 import BucketServiceClient, CreateBucketRequest
service = BucketServiceClient(sdk)
operation = await service.create(CreateBucketRequest(
# fill-in necessary fields
))
await operation.wait()
print(f"New bucket ID: {operation.resource_id}")
```
Or synchronously:
```python
from nebius.api.nebius.storage.v1 import BucketServiceClient, CreateBucketRequest
service = BucketServiceClient(sdk)
operation = service.create(CreateBucketRequest(
# fill-in necessary fields
)).wait()
operation.wait_sync()
print(f"New bucket ID: {operation.resource_id}")
```
##### Progress tracker
Some operations expose a progress tracker with ETA, work completion, and step
details. You can access it via [`Operation.progress_tracker`](https://nebius.github.io/pysdk/nebius.aio.operation.Operation.html#progress_tracker).
For operations that do not provide progress details (or v1alpha1 operations),
this returns `None`.
Example of polling with a single-line progress display:
```python
from asyncio import sleep
from datetime import datetime
from nebius.base.protos.well_known import local_timezone
while not operation.done():
await operation.update()
tracker = operation.progress_tracker()
parts = [f"waiting for operation {operation.id} to complete:"]
if tracker:
work = tracker.work_fraction()
if work is not None:
parts.append(f"{work:.0%}")
desc = tracker.description()
if desc:
parts.append(desc)
started = tracker.started_at()
if started is not None:
elapsed = datetime.now(local_timezone) - started
parts.append(f"{elapsed}")
eta = tracker.estimated_finished_at()
if eta is not None:
parts.append(f"eta {eta}")
print(" ".join(parts), end="\r", flush=True)
await sleep(1)
print()
```
##### Operations service
If you need to get an operation or list operations, you will need an [`OperationServiceClient`](https://nebius.github.io/pysdk/nebius.api.nebius.common.v1.OperationServiceClient.html).
The [`OperationServiceClient`](https://nebius.github.io/pysdk/nebius.api.nebius.common.v1.OperationServiceClient.html), despite being located in [`nebius.api.nebius.common.v1`](https://nebius.github.io/pysdk/nebius.api.nebius.common.v1.html), **cannot** be used the same way as other services. The real operation service must be acquired from the source service of your operation using [`service.operation_service()`](https://nebius.github.io/pysdk/nebius.aio.client.ClientWithOperations.html#operation_service) method.
Example of listing operations and getting operation by service (only async for brevity):
```python
from nebius.api.nebius.common.v1 import GetOperationRequest, ListOperationsRequest
from nebius.api.nebius.storage.v1 import BucketServiceClient
service = BucketServiceClient(sdk)
op_service = service.operation_service()
resp = await op_service.list(ListOperationsRequest(resource_id="your-bucket-id"))
op_id = resp.operations[0].id # The elements of resp.operations are not of type Operation!
real_operation = await op_service.get(GetOperationRequest(id=op_id))
# Get returns the real operation that can be awaited.
await real_operation.wait()
```
**NOTE** As you can see from the example, only [`get`](https://nebius.github.io/pysdk/nebius.api.nebius.common.v1.OperationServiceClient.html#get) will return a fully functional [`Operation`](https://nebius.github.io/pysdk/nebius.aio.operation.Operation.html). Other methods like [`list`](https://nebius.github.io/pysdk/nebius.api.nebius.common.v1.OperationServiceClient.html#list) or [`list_operations_by_parent`](https://nebius.github.io/pysdk/nebius.api.nebius.compute.v1.DiskServiceClient.html#list_operations_by_parent) from Compute will contain an internal [`Operation`](https://nebius.github.io/pysdk/nebius.api.nebius.common.v1.Operation.html) representation object, that cannot be awaited or polled as a normal [`Operation`](https://nebius.github.io/pysdk/nebius.aio.operation.Operation.html).
##### Timeouts and retries
Requests made through the SDK include an internal retry layer and two related timeout concepts:
- Overall request timeout: a deadline that bounds the whole request call including all retries.
- Per-retry timeout: an optional timeout applied to each individual retry attempt. If a per-retry timeout is not explicitly provided, it defaults to the overall request timeout.
By default the SDK sets an overall request timeout of 60 seconds and a per-retry timeout of 20 seconds (i.e. 60/3). If you want to disable timeouts for a specific call, pass an explicit timeout of `None` (for example: `service.get(req, timeout=None)`); note that disabling timeouts can lead to requests hanging indefinitely.
Retries may fail for many reasons (not only timeouts) — network errors, resource exhaustion, quota errors, or service-side failures can all stop a retry loop. If you expect retries to sometimes hang (for example, waiting on a slow resource), consider setting a smaller per-retry timeout so stuck attempts fail faster and allow the retry logic to continue or surface an error sooner.
Operations add one more timeout level: an operation-level timeout that bounds the entire operation lifecycle (waiting for completion). Because of that, the timeouts for each operation update request are prefixed with `poll_`.
###### Authentication timeout (auth_timeout)
There is a third, independent timeout that bounds the overall authentication flow for a call. Authentication (e.g., token acquisition/renewal) happens within the request and can retry on certain failures before and during the RPC. The `auth_timeout` limits the total time spent authenticating (including any internal retries) plus the request run wrapped inside the authentication loop.
- Default: 15 minutes (900 seconds)
- Scope: Authentication loop + the request execution enclosed by it
- Behavior:
- Authentication may retry when allowed by the credentials provider (for example, transient network errors or UNAUTHENTICATED responses). All such retries are bounded by `auth_timeout`.
- For synchronous usage (e.g., `.wait()`), the same `auth_timeout` bounds the overall waiting time.
- Per-call override: pass `auth_timeout` to any service method, for example:
```python
response = await service.get(req, auth_timeout=300.0) # 5 minutes
```
- Disable the authentication deadline by passing `auth_timeout=None` (be careful: this can cause calls to wait indefinitely if authentication never succeeds).
Notes:
- `auth_timeout` starts at the beginning of the request, caps the `timeout` of the authorized request, which itself caps each `per_retry_timeout`.
- If you use token renewal options (see below), individual token-exchange attempts may have their own short deadlines; `auth_timeout` caps the aggregate time across multiple attempts.
##### Retrieve additional metadata
Sometimes you need more than just a result of your request. For instance, if you have problems, you may want to provide more information about the request to the Nebius support team. Service methods do not return basic coroutines, they return [`Request`](https://nebius.github.io/pysdk/nebius.aio.request.Request.html) objects, that can provide more information about the request itself.
Here is an example how to retrieve the request ID and the trace ID for referencing. In most cases, the error will contain them already, but maybe you want to reference a successful request as well. The example:
```python
request = service.get(req) # Note, that we don't await immediately
# all three can be awaited in any order, or simultaneously
response = await request
request_id = await request.request_id()
trace_id = await request.trace_id()
log.info(f"Server answered: {response}; Request ID: {request_id} and Trace ID: {trace_id}")
```
Or in the case of a synchronous context:
```python
request = service.get(req) # Note, that we don't await immediately
# all three can be called in any order, the first call will start the request and wait till completion
response = request.wait()
request_id = request.request_id_sync()
trace_id = request.trace_id_sync()
log.info(f"Server answered: {response}; Request ID: {request_id} and Trace ID: {trace_id}")
```
##### Parse errors
Sometimes things go wrong. There are many `Exception`s a request can raise, but some of them are created on a server and sent back. These exceptions will derive from the [`nebius.aio.service_error.RequestError`](https://nebius.github.io/pysdk/nebius.aio.service_error.RequestError.html). This error will contain a request status and additional information from the server, if there was any.
You can simply print the `RequestError` to see all the info in a readable format, or you can parse it and retrieve the [`nebius.aio.service_error.RequestStatusExtended`](https://nebius.github.io/pysdk/nebius.aio.service_error.RequestStatusExtended.html) located in the `err.status` of the excepted error `err`. It will contain all the information in the structured form.
```python
from nebius.aio.service_error import RequestError
try:
response = await service.get(req)
except RequestError as err:
log.exception(f"Caught request error {err}")
```
Do not forget to save both the request ID and the trace ID from the output, in case you will have to submit something to the support.
### Calling `update` methods on resources
Any `update` method on resources requires either to pass a manually constructed [`x-resetmask`](https://nebius.github.io/pysdk/nebius.base.fieldmask.Mask.html) or to send a full resource specification, previously obtained by the corresponding `get` method and then modified by your code. Here are both examples:
#### Sending a full specification
Here is an example of doubling the limit on the bucket. In this example, we receive the specification, change it and then send it back.
```python
from nebius.api.nebius.storage.v1 import UpdateBucketRequest
bucket = await service.get(req)
bucket.spec.max_size_bytes *= 2 # Example of the change
operation = await service.update(
UpdateBucketRequest(
metadata=bucket.metadata,
spec=bucket.spec,
),
)
```
This operation respects the resource version, thus if somebody was modifying the same resource at the same time, one of your requests will not be accepted. You may omit resource version check by resetting the `metadata.resource_version`. Simply set it to **0** and your update will be applied in any situation:
```python
from nebius.api.nebius.storage.v1 import UpdateBucketRequest
bucket = await service.get(req)
bucket.spec.max_size_bytes *= 2 # Example of the change
bucket.metadata.resource_version = 0 # This will skip version check and fully overwrite the resource
operation = await service.update(
UpdateBucketRequest(
metadata=bucket.metadata,
spec=bucket.spec,
),
)
```
This will **fully replace** the bucket specification with the one you've sent, overwriting any changes that could have been made by any concurrent updates.
#### Updating with manually set `X-ResetMask`
You may want to send partial updates without requesting a full specification beforehand, if your update does not require incremental changes, but only value replacements. This process will require manual setting of the `X-ResetMask` in the metadata, if you need to set any value to its default (in terms of ProtoBuf). Any unset or default fields without the mask set, will not be overwritten.
Here is an example of resetting the limit on the bucket:
```python
from nebius.api.nebius.storage.v1 import UpdateBucketRequest
from nebius.api.nebius.common.v1 import ResourceMetadata
from nebius.base.metadata import Metadata
md = Metadata()
md["X-ResetMask"] = "spec.max_size_bytes"
operation = await service.update(
UpdateBucketRequest(
metadata=ResourceMetadata(
id="some-bucket-id", # Required to identify the resource
)
),
metadata=md,
)
```
This example will only reset `max_size_bytes` in the bucket, clearing the limit, but won't unset or change anything else.
> **Note**: Our internal field masks have more granularity than google ones, so they are incompatible. You can read more on the masks in the Nebius API documentation.
> **Note**: Please read the API documentation before modifying lists and maps using manually set masks.
### User-agent
You can add your own user-agent parts to the user-agent sent to the server.
You can do it either by adding `grpc.primary_user_agent` option in your SDK `options` or `address_options`, or by setting `user_agent_prefix` option of the SDK. The resulting user-agents will be combined together roughly as:
```python
" ".join([
[all option['grpc.primary_user_agent'] from options],
[all option['grpc.primary_user_agent'] from address_options for current address],
user_agent_prefix if set,
pysdk user agent,
grpc user agent, # added by gRPC itself
[all option['grpc.secondary_user_agent'] from options],
[all option['grpc.secondary_user_agent'] from address_options for current address],
])
```
### Contributing
Contributions are welcome! Please refer to the [contributing guidelines](CONTRIBUTING.md) for more information.
### License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
Copyright (c) 2025 Nebius B.V.
| text/markdown | null | Daniil Drizhuk <complynx@nebius.com>, Ivan Kornilov <ivan.kornilov@nebius.com>, Marat Reymers <marat-reymers@nebius.com>, Andrei Zenkov <andrei.zenkov@nebius.com> | null | null | The MIT License (MIT)
Copyright (c) 2025 Nebius B.V.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
| null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"cryptography>=40.0.0",
"pyyaml>=5",
"grpcio>=1.56.2",
"PyJWT>=2.0.0",
"certifi>=2022.6.15",
"protobuf>=5.29.1",
"grpcio-status>=1.56.2",
"portalocker>=2.8.1",
"aiohttp>=3.8.5",
"certifi-win32; extra == \"windows\"",
"pytest>=8.0; extra == \"dev\"",
"pytest-asyncio>=0.24.0; extra == \"dev\"",
... | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:09:55.119931 | nebius-0.3.37.tar.gz | 845,943 | fc/37/ccbb257d780d57886c7c3be74cc5ae4cedfc4457800e190b739971035a1e/nebius-0.3.37.tar.gz | source | sdist | null | false | f5b5a850ba4f8952cc82b3a52d5e001e | 0be3ecfc988bd7e62ed870174f4956609e12ad199638668ca4568dbe0feb4383 | fc37ccbb257d780d57886c7c3be74cc5ae4cedfc4457800e190b739971035a1e | null | [
"LICENSE",
"NOTICE.md",
"AUTHORS"
] | 23,097 |
2.4 | h2spacex | 1.2.1 | HTTP/2 Single Packet Attack low level library based on Scapy | # <img src="https://github.com/nxenon/h2spacex/assets/61124903/fd6387bf-15e8-4a5d-816b-cf5e079e07cc" width="20%" valign="middle" alt="H2SpaceX" /> H2SpaceX
[](https://pypi.org/project/h2spacex/)
[](https://www.python.org)
[](https://github.com/nxenon/h2spacex/blob/main/LICENSE)
HTTP/2 low level library based on Scapy which can be used for Single Packet Attack (Race Condition on H2)
# Dive into Single Packet Attack Article
I wrote an article and published it at InfoSec Write-ups:
- [Dive into Single Packet Attack](https://infosecwriteups.com/dive-into-single-packet-attack-3d3849ffe1d2)
# TODO
- [Single Packet Attack - POST](https://github.com/nxenon/h2spacex/wiki/Quick-Start-Examples)
- [x] implement
- [Single Packet Attack - GET](https://github.com/nxenon/h2spacex/wiki/GET-SPA-Methods)
- [x] Content-Length: 1 Method
- [x] POST Request with x-override-method: GET header
- Response Parsing
- [x] implement
- [x] implement threaded response parser
- [x] add response times in nano seconds for timing attacks
- [x] Body Decompression
- [x] gzip
- [x] br
- [x] deflate
- [Proxy](https://github.com/nxenon/h2spacex/wiki/Quick-Start-Examples#proxy-example)
- [x] Socks5 Proxy
# More Research
Some following statements are just ideas and not tested or implemented.
- More Request in a Single Packet
- Increase MSS (Idea by James Kettle)
- Out of Order TCP Packets (Idea by James Kettle)
- IP Fragmentation
- Proxy the Single Packet Request through SOCKS
- Single Packet Attack on GET Requests
- [Content-Length: 1 Method](https://github.com/nxenon/h2spacex/wiki/GET-SPA-Methods) (Idea by James Kettle)
- [x-override-method: GET](https://github.com/nxenon/h2spacex/wiki/GET-SPA-Methods) Method (Idea by James Kettle)
- Index HPACK Headers to Make GET Requests Smaller
- HEADERS Frame without END_HEADER Flag
- HEADERS Frame Without Some Pseudo Headers
# Installation
H2SpaceX works with Python 3 (preferred: >=3.8.8)
pip install h2spacex
## Error in Installation
if you get errors of scapy:
pip install --upgrade scapy
# Quick Start
You can import the HTTP/2 TLS Connection and set up the connection. After setting up the connection, you can do other things:
```python
from h2spacex import H2OnTlsConnection
h2_conn = H2OnTlsConnection(
hostname='http2.github.io',
port_number=443,
ssl_log_file_path="PATH_TO_SSL_KEYS.log" # optional (if you want to log ssl keys to read the http/2 traffic in wireshark)
)
h2_conn.setup_connection()
...
```
see more examples in [Wiki Page](https://github.com/nxenon/h2spacex/wiki/Quick-Start-Examples)
# Examples
See examples which contain some Portswigger race condition examples.
[Examples Page](./examples)
# Enhanced Single Packet Attack Method (Black Hat 2024) for Timing Attacks
James Kettle introduced an improved version of Single Packet Attack in Black Hat 2024 for timing attacks:
You can implement this method easily using `send_ping_frame()` method.
See this Wiki and `Parse Response (Threaded) + Response Times for Timing Attacks` part:
- [New Method README (WIKI)](https://github.com/nxenon/h2spacex/wiki/SPA-New-Method)
[Improved Version of SPA Sample Exploit](./examples/improved-spa-method.py)
## Reference of Improved Method:
- [Listen to the whispers: web timing attacks that actually work](https://portswigger.net/research/listen-to-the-whispers-web-timing-attacks-that-actually-work)
# References & Resources
- [James Kettle DEF CON 31 Presentation](https://youtu.be/tKJzsaB1ZvI?si=6uAuzOt3wjnEGYP6)
- [Portswigger Research Page](https://portswigger.net/research/smashing-the-state-machine#single-packet-attack)
- [HTTP/2 in Action Book](https://www.manning.com/books/http2-in-action)
I also got some ideas from a previous developed library [h2tinker](https://github.com/kspar/h2tinker).
Finally, thanks again to James Kettle for directly helping and pointing some other techniques.
| text/markdown | nxenon | nxenon <nasiri.aminm@gmail.com> | null | null | GPL-3.0 | race-condition, http2, single-packet-attack | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
"Operating System :: OS Independent"
] | [] | https://github.com/nxenon/h2spacex | null | >=3.8.8 | [] | [] | [] | [
"scapy==2.5.0",
"brotlipy==0.7.0",
"PySocks==1.7.1"
] | [] | [] | [] | [
"Homepage, https://github.com/nxenon/h2spacex",
"Bug Tracker, https://github.com/nxenon/h2spacex/issues",
"Wiki, https://github.com/nxenon/h2spacex/wiki",
"Examples, https://github.com/nxenon/h2spacex/wiki/Quick-Start-Examples"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-18T10:09:35.569008 | h2spacex-1.2.1.tar.gz | 26,090 | 43/22/331c5cef9a9b31b6533470bbdde3863601f688d2d5a5a748c4db3fe39518/h2spacex-1.2.1.tar.gz | source | sdist | null | false | 421ff45c4240d179f59f0917d4b5dc0a | 2e4a9ccc03965c4a7a4e617a7080b3fa63bf63b72e27e579aa25f113090ea208 | 4322331c5cef9a9b31b6533470bbdde3863601f688d2d5a5a748c4db3fe39518 | null | [
"LICENSE"
] | 265 |
2.4 | haystack-pydoc-tools | 0.7.0 | Pydoc custom tools for Haystack docs | # haystack-pydoc-tools
[](https://pypi.org/project/haystack-pydoc-tools)
[](https://pypi.org/project/haystack-pydoc-tools)
-----
Tool to generate Docusaurus-compatible Markdown API references from Python docstrings.
It uses [griffe](https://github.com/mkdocstrings/griffe) to parse source code and [griffe2md](https://github.com/mkdocstrings/griffe2md) to render the output.
## Installation
```console
pip install haystack-pydoc-tools
```
## Usage
The tool reads YAML configuration files and generates Markdown API docs.
**Process a single config file:**
```console
haystack-pydoc config.yml [output-directory]
```
**Process a directory of config files (in parallel):**
```console
haystack-pydoc pydoc/ output/
```
A `pydoc-markdown` alias is also available for backward compatibility.
### Output behavior
Each config must specify a `filename`.
By default, the file is written in the current working directory; if an output directory
is provided, the file is written there instead.
## Configuration
Each `.yml` file describes which modules to document and how to render the output.
### Minimal example
```yaml
loaders:
- search_path: [src]
modules:
- haystack.components.generators.chat.openai
- haystack.components.generators.chat.azure
renderer:
title: Generators
id: generators-api
description: Enables text generation using LLMs.
filename: generators_api.md
```
### Full example
```yaml
loaders:
- search_path: [../src]
modules:
- haystack.components.generators.chat.openai
- haystack.components.generators.chat.azure
processors:
- type: filter
documented_only: false # include objects without docstrings
skip_empty_modules: false # keep modules even if they have no content
renderer:
title: Generators API
id: generators-api
description: Enables text generation using LLMs.
filename: generators_api.md
```
When the `processors` section is omitted, defaults apply: `documented_only: true`, `skip_empty_modules: true`.
### Legacy example
The tool also accepts the older `pydoc-markdown`-style configs. Most fields are ignored but don't cause errors.
```yaml
loaders:
- type: haystack_pydoc_tools.loaders.CustomPythonLoader # ignored
search_path: [../src]
modules:
- haystack.components.generators.chat.openai
- haystack.components.generators.chat.azure
ignore_when_discovered: ["__init__"] # ignored
processors:
- type: filter
expression: # ignored
documented_only: true
do_not_filter_modules: false # ignored
skip_empty_modules: true
- type: smart # ignored
- type: crossref # ignored
renderer:
type: haystack_pydoc_tools.renderers.DocusaurusRenderer # ignored
title: Generators API
id: generators-api
description: Enables text generation using LLMs.
markdown:
descriptive_class_title: false # ignored
classdef_code_block: false # ignored
descriptive_module_title: true # ignored
add_method_class_prefix: true # ignored
add_member_class_prefix: false # ignored
filename: generators_api.md
```
## License
`haystack-pydoc-tools` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.
## Release process
To release version `x.y.z`:
1. Manually update the version in `src/haystack_pydoc_tools/__about__.py` (via a PR or a direct push to `main`).
2. From the `main` branch, create a tag locally: `git tag vx.y.z`.
3. Push the tag: `git push --tags`.
4. Wait for the CI to release the package on PyPI.
| text/markdown | null | Massimiliano Pippi <mpippi@gmail.com> | null | null | null | null | [
"Development Status :: 4 - Beta",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming... | [] | null | null | >=3.10 | [] | [] | [] | [
"black",
"griffe",
"griffe2md",
"pyyaml"
] | [] | [] | [] | [
"Documentation, https://github.com/unknown/haystack-pydoc-tools#readme",
"Issues, https://github.com/unknown/haystack-pydoc-tools/issues",
"Source, https://github.com/unknown/haystack-pydoc-tools"
] | Hatch/1.16.3 cpython/3.12.3 HTTPX/0.28.1 | 2026-02-18T10:08:57.604041 | haystack_pydoc_tools-0.7.0.tar.gz | 26,827 | cf/2d/1173be4a621a4c1e1bfd87079ec37c29ab25953b7c0e359f682f19c2c45b/haystack_pydoc_tools-0.7.0.tar.gz | source | sdist | null | false | 9cad261472c1bfbb2601d09a72e75841 | ef23eef95baae3fcbd73ad6e8cf3c0ae757c301437a3a540fde4aa322d9f4e6f | cf2d1173be4a621a4c1e1bfd87079ec37c29ab25953b7c0e359f682f19c2c45b | Apache-2.0 | [
"LICENSE"
] | 11,592 |
2.4 | dbt-glue | 1.10.19 | dbt adapter for AWS Glue | <p align="center">
<img src="/etc/dbt-logo-full.svg" alt="dbt logo" width="500"/>
</p>
**[dbt](https://www.getdbt.com/)** enables data analysts and engineers to transform their data using the same practices that software engineers use to build applications.
dbt is the T in ELT. Organize, cleanse, denormalize, filter, rename, and pre-aggregate the raw data in your warehouse so that it's ready for analysis.
# dbt-glue
The `dbt-glue` package implements the [dbt adapter](https://docs.getdbt.com/docs/contributing/building-a-new-adapter) protocol for AWS Glue's Spark engine.
It supports running dbt against Spark, through the new Glue Interactive Sessions API.
To learn how to deploy a data pipeline in your modern data platform using the `dbt-glue` adapter, please read the following blog post: [Build your data pipeline in your AWS modern data platform using AWS Lake Formation, AWS Glue, and dbt Core](https://aws.amazon.com/blogs/big-data/build-your-data-pipeline-in-your-aws-modern-data-platform-using-aws-lake-formation-aws-glue-and-dbt-core/)
## Installation
The package can be installed from PyPI with:
```bash
$ pip3 install dbt-glue
```
For further (and more likely up-to-date) info, see the [README](https://github.com/aws-samples/dbt-glue#readme)
## Connection Methods
### Configuring your AWS profile for Glue Interactive Session
There are two IAM principals used with interactive sessions.
- Client principal: The princpal (either user or role) calling the AWS APIs (Glue, Lake Formation, Interactive Sessions)
from the local client. This is the principal configured in the AWS CLI and likely the same.
- Service role: The IAM role that AWS Glue uses to execute your session. This is the same as AWS Glue
ETL.
Read [this documentation](https://docs.aws.amazon.com/glue/latest/dg/glue-is-security.html) to configure these principals.
You will find bellow a least privileged policy to enjoy all features of **`dbt-glue`** adapter.
Please to update variables between **`<>`**, here are explanations of these arguments:
|Args |Description |
|---|---|
|region|The region where your Glue database is stored |
|AWS Account|The AWS account where you run your pipeline|
|dbt output database|The database updated by dbt (this is the schema configured in the profile.yml of your dbt environment)|
|dbt source database|All databases used as source|
|dbt output bucket|The bucket name where the data will be generate dbt (the location configured in the profile.yml of your dbt environment)|
|dbt source bucket|The bucket name of source databases (if they are not managed by Lake Formation)|
```yaml
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Read_and_write_databases",
"Action": [
"glue:SearchTables",
"glue:BatchCreatePartition",
"glue:CreatePartitionIndex",
"glue:DeleteDatabase",
"glue:GetTableVersions",
"glue:GetPartitions",
"glue:DeleteTableVersion",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:DeletePartitionIndex",
"glue:GetTableVersion",
"glue:UpdateColumnStatisticsForTable",
"glue:CreatePartition",
"glue:UpdateDatabase",
"glue:CreateTable",
"glue:GetTables",
"glue:GetDatabases",
"glue:GetTable",
"glue:GetDatabase",
"glue:GetPartition",
"glue:UpdateColumnStatisticsForPartition",
"glue:CreateDatabase",
"glue:BatchDeleteTableVersion",
"glue:BatchDeleteTable",
"glue:DeletePartition",
"glue:GetUserDefinedFunctions",
"lakeformation:ListResources",
"lakeformation:BatchGrantPermissions",
"lakeformation:ListPermissions",
"lakeformation:GetDataAccess",
"lakeformation:GrantPermissions",
"lakeformation:RevokePermissions",
"lakeformation:BatchRevokePermissions",
"lakeformation:AddLFTagsToResource",
"lakeformation:RemoveLFTagsFromResource",
"lakeformation:GetResourceLFTags",
"lakeformation:ListLFTags",
"lakeformation:GetLFTag",
],
"Resource": [
"arn:aws:glue:<region>:<AWS Account>:catalog",
"arn:aws:glue:<region>:<AWS Account>:table/<dbt output database>/*",
"arn:aws:glue:<region>:<AWS Account>:database/<dbt output database>"
],
"Effect": "Allow"
},
{
"Sid": "Read_only_databases",
"Action": [
"glue:SearchTables",
"glue:GetTableVersions",
"glue:GetPartitions",
"glue:GetTableVersion",
"glue:GetTables",
"glue:GetDatabases",
"glue:GetTable",
"glue:GetDatabase",
"glue:GetPartition",
"lakeformation:ListResources",
"lakeformation:ListPermissions"
],
"Resource": [
"arn:aws:glue:<region>:<AWS Account>:table/<dbt source database>/*",
"arn:aws:glue:<region>:<AWS Account>:database/<dbt source database>",
"arn:aws:glue:<region>:<AWS Account>:database/default",
"arn:aws:glue:<region>:<AWS Account>:database/global_temp"
],
"Effect": "Allow"
},
{
"Sid": "Storage_all_buckets",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::<dbt output bucket>",
"arn:aws:s3:::<dbt source bucket>"
],
"Effect": "Allow"
},
{
"Sid": "Read_and_write_buckets",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::<dbt output bucket>"
],
"Effect": "Allow"
},
{
"Sid": "Read_only_buckets",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::<dbt source bucket>"
],
"Effect": "Allow"
}
]
}
```
### Configuration of the local environment
Because **`dbt`** and **`dbt-glue`** adapter are compatible with Python versions 3.7, 3.8, and 3.9, check the version of Python:
```bash
$ python3 --version
```
Configure a Python virtual environment to isolate package version and code dependencies:
```bash
$ python3 -m venv dbt_venv
$ source dbt_venv/bin/activate
$ python3 -m pip install --upgrade pip
```
Configure the last version of AWS CLI
```bash
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
$ unzip awscliv2.zip
$ sudo ./aws/install
```
Install boto3 package
```bash
$ sudo yum install gcc krb5-devel.x86_64 python3-devel.x86_64 -y
$ pip3 install --upgrade boto3
```
Install the package:
```bash
$ pip3 install dbt-glue
```
### Example config
```yml
type: glue
query-comment: This is a glue dbt example
role_arn: arn:aws:iam::1234567890:role/GlueInteractiveSessionRole
region: us-east-1
workers: 2
worker_type: G.1X
idle_timeout: 10
schema: "dbt_demo"
session_provisioning_timeout_in_seconds: 120
location: "s3://dbt_demo_bucket/dbt_demo_data"
```
The table below describes all the options.
| Option | Description | Mandatory |
|-----------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------|
| project_name | The dbt project name. This must be the same as the one configured in the dbt project. | yes |
| type | The driver to use. | yes |
| query-comment | A string to inject as a comment in each query that dbt runs. | no |
| role_arn | The ARN of the glue interactive session IAM role. | yes |
| region | The AWS Region were you run the data pipeline. | yes |
| workers | The number of workers of a defined workerType that are allocated when a job runs. | yes |
| worker_type | The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, or G.2X. | yes |
| schema | The schema used to organize data stored in Amazon S3.Additionally, is the database in AWS Lake Formation that stores metadata tables in the Data Catalog. | yes |
| session_provisioning_timeout_in_seconds | The timeout in seconds for AWS Glue interactive session provisioning. | yes |
| location | The Amazon S3 location of your target data. | yes |
| query_timeout_in_minutes | The timeout in minutes for a signle query. Default is 300 | no |
| idle_timeout | The AWS Glue session idle timeout in minutes. (The session stops after being idle for the specified amount of time) | no |
| glue_version | The version of AWS Glue for this session to use. Currently, the only valid options are 2.0, 3.0 and 4.0. The default value is 4.0. | no |
| security_configuration | The security configuration to use with this session. | no |
| connections | A comma-separated list of connections to use in the session. | no |
| conf | Specific configuration used at the startup of the Glue Interactive Session (arg --conf) | no |
| extra_py_files | Extra python Libs that can be used by the interactive session. | no |
| delta_athena_prefix | A prefix used to create Athena compatible tables for Delta tables (if not specified, then no Athena compatible table will be created) | no |
| tags | The map of key value pairs (tags) belonging to the session. Ex: `KeyName1=Value1,KeyName2=Value2` | no |
| seed_format | By default `parquet`, can be Spark format compatible like `csv` or `json` | no |
| seed_mode | By default `overwrite`, the seed data will be overwritten, you can set it to `append` if you just want to add new data in your dataset | no |
| default_arguments | The map of key value pairs parameters belonging to the session. More information on [Job parameters used by AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html). Ex: `--enable-continuous-cloudwatch-log=true,--enable-continuous-log-filter=true` | no |
| glue_session_id | re-use a glue-session to run multiple dbt run commands. Will create a new glue-session using glue_session_id if it does not exists yet. | no |
| glue_session_reuse | re-use the glue-session to run multiple dbt run commands: If set to true, the glue session will not be closed for re-use. If set to false, the session will be closed. The glue session will close after idle_timeout time is expired after idle_timeout time | no |
| group_session_id | [**Model Level Meta Setting**] Set a specific glue session suffix id to group sets of models together to a specific session id. Good for models that have chained dependencies in a larger dag and you want to save on session startup times. | no |
| datalake_formats | The ACID datalake format that you want to use if you are doing merge, can be `hudi`, `iceberg` or `delta` |no|
| use_arrow | (experimental) use an arrow file instead of stdout to have better scalability. |no|
| enable_spark_seed_casting | Allows spark to cast the columns depending on the specified model column types. Default `False`. |no|
## Configs
### Configuring tables
When materializing a model as `table`, you may include several optional configs that are specific to the dbt-spark plugin, in addition to the standard model configs.
| Option | Description | Required? | Example |
|-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------|---------------------------------------------------|
| file_format | The file format to use when creating tables (`parquet`, `csv`, `json`, `text`, `jdbc`, `orc`, `delta`, `iceberg`, `hudi`, or `s3tables`). | Optional | `parquet` |
| partition_by | Partition the created table by the specified columns. A directory is created for each partition. | Optional | `date_day` |
| clustered_by | Each partition in the created table will be split into a fixed number of buckets by the specified columns. | Optional | `country_code` |
| buckets | The number of buckets to create while clustering | Required if `clustered_by` is specified | `8` |
| custom_location | By default, the adapter will store your data in the following path: `location path`/`schema`/`table`. If you don't want to follow that default behaviour, you can use this parameter to set your own custom location on S3 | No | `s3://mycustombucket/mycustompath` |
| hudi_options | When using file_format `hudi`, gives the ability to overwrite any of the default configuration options. | Optional | `{'hoodie.schema.on.read.enable': 'true'}` |
| meta | Spawns isolated Glue session with different session configuration. Use Case: When specific models require configurations different from the default session settings. For example, a particular model might require more Glue workers or larger worker type. | Optional | `meta = { "workers": 50, "worker_type": "G.1X" }` |
| add_iceberg_timestamp | Add `update_iceberg_ts` column on Iceberg tables. (default: false) | Optional | `true` |
| use_iceberg_temp_views | Use Spark temporary views when using Iceberg targets instead of physical tables to store intermediate results. (default: false) | Optional | `true` |
| purge_dropped_iceberg_data | Purge Iceberg and S3 Tables underlying data S3 object during drop table. (default: false) | Optional | `true` |
## Amazon S3 Tables Support (Experimental)
**WARNING: Experimental Feature**: Amazon S3 Tables support is currently experimental and may have limitations or breaking changes in future versions.
dbt-glue supports [Amazon S3 Tables](https://aws.amazon.com/s3/features/tables/), a new table type for analytics workloads that provides Apache Iceberg compatibility with automatic optimization and management.
### Configuration
To use S3 Tables, set `file_format='s3tables'` in your model configuration:
```sql
{{ config(
materialized='table',
file_format='s3tables'
) }}
select
id,
name,
created_at
from {{ ref('source_table') }}
```
### Profile Configuration
S3 Tables require specific Spark configurations in your `profiles.yml`:
```yaml
your_profile:
target: dev
outputs:
dev:
type: glue
# ... other configurations ...
conf: >-
spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.defaultCatalog=glue_catalog
--conf spark.sql.catalog.glue_catalog.warehouse=s3://your-warehouse-path
--conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
--conf spark.sql.catalog.glue_catalog.glue.id=YOUR_ACCOUNT_ID:s3tablescatalog/your-s3-tables-bucket
datalake_formats: iceberg
```
### Example Model
```sql
{{ config(
materialized='table',
file_format='s3tables',
partition_by=['year', 'month']
) }}
select
customer_id,
order_date,
extract(year from order_date) as year,
extract(month from order_date) as month,
total_amount
from {{ ref('raw_orders') }}
where order_date >= '2024-01-01'
```
### Requirements
- **AWS Glue 4.0 or later** (recommended)
- **S3 Tables bucket** configured in your AWS account
- **Proper IAM permissions** for S3 Tables operations
- **Iceberg Spark extensions** configured in your profile
## Python models (Experimental)
**WARNING: Experimental Feature**: Python model support is currently experimental and may have limitations or breaking changes in future versions.
dbt-glue supports [Python models](https://docs.getdbt.com/docs/build/python-models) that allow you to apply transformations to your data using Python code and libraries, rather than SQL. This enables more complex data transformations, statistical analysis, and machine learning workflows within your dbt project.
### Requirements
- **AWS Glue version 4.0 or later** (recommended for best Python support)
- **Iceberg file format** (required for Python models)
- **Proper Iceberg configuration** in your profile (see configuration example below)
### Configuration
Python models require Iceberg file format and specific Spark configurations. Add the following to your `profiles.yml`:
```yaml
your_profile:
target: dev
outputs:
dev:
type: glue
# ... other configurations ...
datalake_formats: iceberg
conf: >-
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.catalog.glue_catalog.warehouse=s3://your-warehouse-path
--conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
```
### Basic Usage
Create a Python model by adding a `.py` file to your `models/` directory:
```python
def model(dbt, spark):
# Configure the model
dbt.config(materialized='python_model', file_format='iceberg')
# Create your DataFrame using Spark
data = [
(1, 'Alice', 100),
(2, 'Bob', 200),
(3, 'Charlie', 300)
]
columns = ['id', 'name', 'value']
# Return a Spark DataFrame
return spark.createDataFrame(data, columns)
```
### Referencing Other Models
You can reference other dbt models and sources in your Python models:
```python
def model(dbt, spark):
dbt.config(materialized='python_model', file_format='iceberg')
# Reference another dbt model
customers_df = dbt.ref('customers')
# Reference a source
orders_df = dbt.source('raw_data', 'orders')
# Perform transformations
result_df = customers_df.join(orders_df, 'customer_id')
return result_df
```
### Incremental Python Models
Python models support incremental materialization with merge strategy:
```python
def model(dbt, spark):
dbt.config(
materialized='incremental',
file_format='iceberg',
incremental_strategy='merge',
unique_key='id'
)
# Get source data
source_df = dbt.ref('raw_events')
if dbt.is_incremental():
# Only process new records for incremental runs
max_date = spark.sql(f"SELECT MAX(event_date) FROM {dbt.this}").collect()[0][0]
source_df = source_df.filter(source_df.event_date > max_date)
# Apply transformations
transformed_df = source_df.groupBy('user_id').agg(
count('*').alias('event_count'),
max('event_date').alias('last_event_date')
)
return transformed_df
```
### Configuration Options
Python models support the same configuration options as regular models, plus some Python-specific ones:
| Option | Description | Example |
|--------|-------------|---------|
| `materialized` | Materialization type (`python_model` or `incremental`) | `python_model` |
| `file_format` | File format (must be `iceberg` for Python models) | `iceberg` |
| `incremental_strategy` | Strategy for incremental models | `merge` |
| `unique_key` | Unique key for merge operations | `['id']` |
| `partition_by` | Partition columns | `['date_column']` |
### Limitations
- **File format**: Only Iceberg file format is supported for Python models
- **Glue version**: Requires AWS Glue 4.0 or later for optimal support
- **Session configuration**: Requires proper Iceberg Spark extensions configuration
- **Return type**: Model function must return exactly one Spark DataFrame
- **Performance**: Python models may have longer execution times compared to SQL models
### Best Practices
1. **Use appropriate file formats**: Always use `file_format='iceberg'` for Python models
2. **Optimize DataFrame operations**: Use Spark DataFrame operations efficiently
3. **Handle incremental logic**: Use `dbt.is_incremental()` for conditional processing
4. **Test thoroughly**: Python models are experimental, so test extensively
5. **Monitor performance**: Python models may require more resources than SQL models
### Example: Data Science Workflow
```python
def model(dbt, spark):
dbt.config(
materialized='python_model',
file_format='iceberg',
partition_by=['analysis_date']
)
# Import required libraries (available in Glue environment)
from pyspark.sql.functions import col, when, avg, stddev
from datetime import datetime
# Get source data
sales_df = dbt.ref('sales_data')
# Perform statistical analysis
stats_df = sales_df.groupBy('product_category').agg(
avg('sales_amount').alias('avg_sales'),
stddev('sales_amount').alias('stddev_sales'),
count('*').alias('transaction_count')
)
# Add analysis metadata
result_df = stats_df.withColumn('analysis_date', lit(datetime.now().date()))
return result_df
```
## Incremental models
dbt seeks to offer useful and intuitive modeling abstractions by means of its built-in configurations and materializations.
For that reason, the dbt-glue plugin leans heavily on the [`incremental_strategy` config](configuring-incremental-models#about-incremental_strategy). This config tells the incremental materialization how to build models in runs beyond their first. It can be set to one of three values:
- **`append`** (default): Insert new records without updating or overwriting any existing data.
- **`insert_overwrite`**: If `partition_by` is specified, overwrite partitions in the table with new data. If no `partition_by` is specified, overwrite the entire table with new data.
- **`merge`** (Apache Hudi and Apache Iceberg only): Match records based on a `unique_key`; update old records, insert new ones. (If no `unique_key` is specified, all new data is inserted, similar to `append`.)
Each of these strategies has its pros and cons, which we'll discuss below. As with any model config, `incremental_strategy` may be specified in `dbt_project.yml` or within a model file's `config()` block.
**Notes:**
The default strategy is **`insert_overwrite`**
### The `append` strategy
Following the `append` strategy, dbt will perform an `insert into` statement with all new data. The appeal of this strategy is that it is straightforward and functional across all platforms, file types, connection methods, and Apache Spark versions. However, this strategy _cannot_ update, overwrite, or delete existing data, so it is likely to insert duplicate records for many data sources.
#### Source code
```sql
{{ config(
materialized='incremental',
incremental_strategy='append',
) }}
-- All rows returned by this query will be appended to the existing table
select * from {{ ref('events') }}
{% if is_incremental() %}
where event_ts > (select max(event_ts) from {{ this }})
{% endif %}
```
#### Run Code
```sql
create temporary view spark_incremental__dbt_tmp as
select * from analytics.events
where event_ts >= (select max(event_ts) from {{ this }})
;
insert into table analytics.spark_incremental
select `date_day`, `users` from spark_incremental__dbt_tmp
```
### The `insert_overwrite` strategy
This strategy is most effective when specified alongside a `partition_by` clause in your model config. dbt will run an [atomic `insert overwrite` statement](https://spark.apache.org/docs/latest/sql-ref-syntax-dml-insert-overwrite-table.html) that dynamically replaces all partitions included in your query. Be sure to re-select _all_ of the relevant data for a partition when using this incremental strategy.
If no `partition_by` is specified, then the `insert_overwrite` strategy will atomically replace all contents of the table, overriding all existing data with only the new records. The column schema of the table remains the same, however. This can be desirable in some limited circumstances, since it minimizes downtime while the table contents are overwritten. The operation is comparable to running `truncate` + `insert` on other databases. For atomic replacement of Delta-formatted tables, use the `table` materialization (which runs `create or replace`) instead.
#### Source Code
```sql
{{ config(
materialized='incremental',
partition_by=['date_day'],
file_format='parquet'
) }}
/*
Every partition returned by this query will be overwritten
when this model runs
*/
with new_events as (
select * from {{ ref('events') }}
{% if is_incremental() %}
where date_day >= date_add(current_date, -1)
{% endif %}
)
select
date_day,
count(*) as users
from events
group by 1
```
#### Run Code
```sql
create temporary view spark_incremental__dbt_tmp as
with new_events as (
select * from analytics.events
where date_day >= date_add(current_date, -1)
)
select
date_day,
count(*) as users
from events
group by 1
;
insert overwrite table analytics.spark_incremental
partition (date_day)
select `date_day`, `users` from spark_incremental__dbt_tmp
```
Specifying `insert_overwrite` as the incremental strategy is optional, since it's the default strategy used when none is specified.
### The `merge` strategy
**Compatibility:**
- Hudi : OK
- Delta Lake : OK
- Iceberg : OK
- Lake Formation Governed Tables : On going
NB:
- For Glue 3: you have to setup a [Glue connectors](https://docs.aws.amazon.com/glue/latest/ug/connectors-chapter.html).
- For Glue 4: use the `datalake_formats` option in your profile.yml
When using a connector be sure that your IAM role has these policies:
```
{
"Sid": "access_to_connections",
"Action": [
"glue:GetConnection",
"glue:GetConnections"
],
"Resource": [
"arn:aws:glue:<region>:<AWS Account>:catalog",
"arn:aws:glue:<region>:<AWS Account>:connection/*"
],
"Effect": "Allow"
}
```
and that the managed policy `AmazonEC2ContainerRegistryReadOnly` is attached.
Be sure that you follow the getting started instructions [here](https://docs.aws.amazon.com/glue/latest/ug/setting-up.html#getting-started-min-privs-connectors).
This [blog post](https://aws.amazon.com/blogs/big-data/part-1-integrate-apache-hudi-delta-lake-apache-iceberg-datasets-at-scale-aws-glue-studio-notebook/) also explain how to setup and works with Glue Connectors
#### Hudi
**Usage notes:** The `merge` with Hudi incremental strategy requires:
- To add `file_format: hudi` in your table configuration
- To add a datalake_formats in your profile : `datalake_formats: hudi`
- Alternatively, to add a connections in your profile : `connections: name_of_your_hudi_connector`
- To add Kryo serializer in your Interactive Session Config (in your profile): `conf: spark.serializer=org.apache.spark.serializer.KryoSerializer --conf spark.sql.hive.convertMetastoreParquet=false`
dbt will run an [atomic `merge` statement](https://hudi.apache.org/docs/writing_data#spark-datasource-writer) which looks nearly identical to the default merge behavior on Snowflake and BigQuery. If a `unique_key` is specified (recommended), dbt will update old records with values from new records that match on the key column. If a `unique_key` is not specified, dbt will forgo match criteria and simply insert all new records (similar to `append` strategy).
#### Profile config example
```yaml
test_project:
target: dev
outputs:
dev:
type: glue
query-comment: my comment
role_arn: arn:aws:iam::1234567890:role/GlueInteractiveSessionRole
region: eu-west-1
glue_version: "4.0"
workers: 2
worker_type: G.1X
schema: "dbt_test_project"
session_provisioning_timeout_in_seconds: 120
location: "s3://aws-dbt-glue-datalake-1234567890-eu-west-1/"
conf: spark.serializer=org.apache.spark.serializer.KryoSerializer --conf spark.sql.hive.convertMetastoreParquet=false
datalake_formats: hudi
```
#### Source Code example
```sql
{{ config(
materialized='incremental',
incremental_strategy='merge',
unique_key='user_id',
file_format='hudi',
hudi_options={
'hoodie.datasource.write.precombine.field': 'eventtime',
}
) }}
with new_events as (
select * from {{ ref('events') }}
{% if is_incremental() %}
where date_day >= date_add(current_date, -1)
{% endif %}
)
select
user_id,
max(date_day) as last_seen
from events
group by 1
```
#### Delta
You can also use Delta Lake to be able to use merge feature on tables.
**Usage notes:** The `merge` with Delta incremental strategy requires:
- To add `file_format: delta` in your table configuration
- To add a datalake_formats in your profile : `datalake_formats: delta`
- Alternatively, to add a connections in your profile : `connections: name_of_your_delta_connector`
- To add the following config in your Interactive Session Config (in your profile): `conf: "spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog`
**Athena:** Athena is not compatible by default with delta tables, but you can configure the adapter to create Athena tables on top of your delta table. To do so, you need to configure the two following options in your profile:
- `delta_athena_prefix: "the_prefix_of_your_choice"`
- If your table is partitioned, then the add of new partition is not automatic, you need to perform an `MSCK REPAIR TABLE your_delta_table` after each new partition adding
#### Profile config example
```yaml
test_project:
target: dev
outputs:
dev:
type: glue
query-comment: my comment
role_arn: arn:aws:iam::1234567890:role/GlueInteractiveSessionRole
region: eu-west-1
glue_version: "4.0"
workers: 2
worker_type: G.1X
schema: "dbt_test_project"
session_provisioning_timeout_in_seconds: 120
location: "s3://aws-dbt-glue-datalake-1234567890-eu-west-1/"
datalake_formats: delta
conf: "spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"
delta_athena_prefix: "delta"
```
#### Source Code example
```sql
{{ config(
materialized='incremental',
incremental_strategy='merge',
unique_key='user_id',
partition_by=['dt'],
file_format='delta'
) }}
with new_events as (
select * from {{ ref('events') }}
{% if is_incremental() %}
where date_day >= date_add(current_date, -1)
{ | text/markdown | moshirm,segnina,sekiyama | moshirm@amazon.fr, segnina@amazon.fr, sekiyama@amazon.com | null | null | null | null | [
"Development Status :: 4 - Beta",
"License :: OSI Approved :: Apache Software License",
"Operating System :: Microsoft :: Windows",
"Operating System :: MacOS :: MacOS X",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programm... | [] | https://github.com/aws-samples/dbt-glue | null | >=3.9 | [] | [] | [] | [
"dbt-core~=1.10.19",
"dbt-spark~=1.9.3",
"dbt-common<3.0,>=1.0.4",
"dbt-adapters<2.0,>=1.1.1",
"waiter",
"pyarrow",
"boto3>=1.28.16"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.13.5 | 2026-02-18T10:08:57.446472 | dbt_glue-1.10.19-py3-none-any.whl | 75,407 | c8/6e/57635a852836d4078e5aea1022ae71266b48ba1ce2e9ef0e74908820be9b/dbt_glue-1.10.19-py3-none-any.whl | py3 | bdist_wheel | null | false | 9b09a1831855db6edcc2d75f0c82c20d | b4a6cb42abf4536566980569d6f173ac5215701d317298a9fde6c21599c09841 | c86e57635a852836d4078e5aea1022ae71266b48ba1ce2e9ef0e74908820be9b | null | [
"LICENSE",
"NOTICE"
] | 6,403 |
2.4 | obiba-opal | 6.0.2 | OBiBa/Opal python client. | # Opal Python [](https://github.com/obiba/opal-python-client/actions/workflows/ci.yml)
This Python-based command line tool allows to access to a Opal server through its REST API. This is the perfect tool
for automating tasks in Opal using shell scripts.
See also the [Opal R Client](https://github.com/obiba/opalr) which offers a comprehensive programming interface.
* Read the [documentation](http://opaldoc.obiba.org).
* Have a bug or a question? Please create a [GitHub issue](https://github.com/obiba/opal-python-client/issues).
* Continuous integration is on [GitHub actions](https://github.com/obiba/opal-python-client/actions).
## Usage
Install with:
```shell
pip install obiba-opal
```
## Development
This project uses [uv](https://docs.astral.sh/uv/) for dependency management and packaging.
### Setup Development Environment
1. Install uv:
See [uv installation](https://docs.astral.sh/uv/getting-started/installation/).
2. Install dependencies:
```shell
uv sync
```
3. Run tests:
```shell
uv run pytest
```
4. Build the package:
```shell
uv build
```
### Requirements
- Python 3.10 or higher
- uv (for development)
### CLI
To get the options of the command line:
```shell
opal --help
```
This command will display which sub-commands are available. For each sub-command you can get the help message as well:
```shell
opal <subcommand> --help
```
The objective of having sub-command is to hide the complexity of applying some use cases to the Opal REST API. More
sub-commands will be developed in the future.
### API
Opal Python client can be easily extended by using the [exposed classes](https://github.com/obiba/opal-python-client/blob/master/obiba_opal/__init__.py). The classes `*Command` return an Opal task object, to be followed with the `TaskService`. The classes `*Service` perform immediate operations.
```python
from obiba_opal import OpalClient, HTTPError, Formatter, ImportCSVCommand, TaskService, FileService, DictionaryService
# if 2-factor auth is enabled, user will be asked for the secret code
# Personal access token authentication is also supported (and recommended)
client = OpalClient.buildWithAuthentication(server='https://opal-demo.obiba.org', user='administrator', password='password')
try:
# upload a local CSV data file into Opal file system
fs = FileService(client)
fs.upload_file('./data.csv', '/tmp')
# import this CSV file into a project
task = ImportCSVCommand(client).import_data('/tmp/data.csv', 'CNSIM')
status = TaskService(client).wait_task(task['id'])
# clean data file from Opal
fs.delete_file('/tmp/data.csv')
if status == 'SUCCEEDED':
dico = DictionaryService(client)
table = dico.get_table('CNSIM', 'data')
# do something ...
dico.delete_tables('CNSIM', ['data'])
else:
print('Import failed!')
# do something ...
except HTTPError as e:
Formatter.print_json(e.error, True)
finally:
client.close()
```
## Mailing list
Have a question? Ask on our mailing list!
obiba-users@googlegroups.com
[http://groups.google.com/group/obiba-users](http://groups.google.com/group/obiba-users)
## License
OBiBa software are open source and made available under the [GPL3 licence](http://www.obiba.org/pages/license/). OBiBa software are free of charge.
## OBiBa acknowledgments
If you are using OBiBa software, please cite our work in your code, websites, publications or reports.
"The work presented herein was made possible using the OBiBa suite (www.obiba.org), a software suite developed by Maelstrom Research (www.maelstrom-research.org)"
| text/markdown | null | Yannick Marcon <yannick.marcon@obiba.org> | null | Yannick Marcon <yannick.marcon@obiba.org> | GPL-3.0-only | data, management, obiba, opal | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python... | [] | null | null | >=3.10 | [] | [] | [] | [
"requests>=2.31.0",
"typer>=0.21.1",
"urllib3>=2.0",
"ruff>=0.10.0; extra == \"dev\"",
"pytest>=7.2.2; extra == \"test\""
] | [] | [] | [] | [
"Homepage, https://www.obiba.org",
"Repository, https://github.com/obiba/opal-python-client",
"Documentation, https://opaldoc.obiba.org/en/latest/python-user-guide/",
"Bug Tracker, https://github.com/obiba/opal-python-client/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-18T10:08:31.526127 | obiba_opal-6.0.2-py3-none-any.whl | 73,491 | 75/b1/a7b653911eeb8e3f44a18e138b2095fd7f93a7b691243b003d215ac6f615/obiba_opal-6.0.2-py3-none-any.whl | py3 | bdist_wheel | null | false | 3a6fd7c0e3faad8ec9505aa8673017a5 | 41c714a3612f81c52b42a8ebf038d876672bf6c7da48ad653466d9b81b397eb3 | 75b1a7b653911eeb8e3f44a18e138b2095fd7f93a7b691243b003d215ac6f615 | null | [
"LICENSE.txt"
] | 352 |
2.4 | ansys-scadeone-core | 0.8.1 | Python interface for Ansys Scade One | PyScadeOne
##########
|pyansys| |pypi| |doc| |license| |ruff| |CI-CD|
.. |pyansys| image:: https://img.shields.io/badge/Py-Ansys-ffc107.svg?labelColor=black&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABDklEQVQ4jWNgoDfg5mD8vE7q/3bpVyskbW0sMRUwofHD7Dh5OBkZGBgW7/3W2tZpa2tLQEOyOzeEsfumlK2tbVpaGj4N6jIs1lpsDAwMJ278sveMY2BgCA0NFRISwqkhyQ1q/Nyd3zg4OBgYGNjZ2ePi4rB5loGBhZnhxTLJ/9ulv26Q4uVk1NXV/f///////69du4Zdg78lx//t0v+3S88rFISInD59GqIH2esIJ8G9O2/XVwhjzpw5EAam1xkkBJn/bJX+v1365hxxuCAfH9+3b9/+////48cPuNehNsS7cDEzMTAwMMzb+Q2u4dOnT2vWrMHu9ZtzxP9vl/69RVpCkBlZ3N7enoDXBwEAAA+YYitOilMVAAAAAElFTkSuQmCC
:target: https://docs.pyansys.com/
:alt: PyAnsys
.. |pypi| image:: https://img.shields.io/pypi/v/ansys-scadeone-core.svg?logo=python&logoColor=white
:target: https://pypi.org/project/ansys-scadeone-core/
:alt: PyPI
.. |doc| image:: https://img.shields.io/badge/docs-pyscadeone-green.svg?style=flat
:target: https://scadeone.docs.pyansys.com/
:alt: Doc
.. |license| image:: https://img.shields.io/badge/License-MIT-yellow.svg
:target: https://opensource.org/licenses/MIT
:alt: MIT License
.. |ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
:target: https://github.com/astral-sh/ruff
:alt: Ruff
.. |CI-CD| image:: https://github.com/ansys/pyscadeone/actions/workflows/ci.yml/badge.svg
:target: https://github.com/ansys/pyscadeone/actions/workflows/ci.yml
:alt: CI-CD
About
=====
PyScadeOne is a Python library for the `Ansys Scade One`_ model-based
development environment.
This library allows:
- Data access
- Reading projects and navigating in models
- Reading and editing simulation data files
- Reading test results
- Reading information about the generated code
- Ecosystem integration
- Exporting `FMI 2.0`_ components
Prerequisites
=============
PyScadeOne requires `.NET runtime 8.0`_.
Installation
============
Refer to the `official installation guidelines`_.
Documentation
=============
The documentation of PyScadeOne contains the following chapters:
- `Getting started`_. This section provides a brief overview and instructions
on how to get started with the project. It typically includes information on
how to install the project, set up any necessary dependencies, and run a
basic example or test to ensure everything is functioning correctly.
- `User guide`_. The user guide section offers detailed documentation and
instructions on how to use the project. It provides comprehensive
explanations of the project's features, functionalities, and configuration
options. The user guide aims to help users understand the project's concepts,
best practices, and recommended workflows.
- `API reference`_. The API reference section provides detailed documentation
for the project's application programming interface (API). It includes
information about classes, functions, methods, and their parameters, return
values, and usage examples. This reference helps developers understand the
available API endpoints, their functionalities, and how to interact with them
programmatically.
- `Examples`_. The examples section showcases practical code examples that
demonstrate how to use the project in real-world scenarios. It provides
sample code snippets or complete scripts that illustrate different use cases
or demonstrate specific features of the project. Examples serve as practical
references for developers, helping them understand how to apply the project
to their own applications.
Documentation contains UML diagrams generated by `PlantUML <https://plantuml.com>`_.
License
=======
The license of the PyScadeOne project is MIT. Read the full text of the license
in the `LICENSE`_ file.
.. References and links
.. _ansys scade one: https://www.ansys.com/products/embedded-software/ansys-scade-one
.. _SCADE Test: https://www.ansys.com/products/embedded-software/ansys-scade-test
.. _FMI 2.0: https://fmi-standard.org/
.. _.Net runtime 8.0: https://dotnet.microsoft.com/en-us/download/dotnet/8.0
.. _official installation guidelines: https://scadeone.docs.pyansys.com/version/dev/getting_started/index.html
.. _getting started: https://scadeone.docs.pyansys.com/version/dev/getting_started/index.html
.. _user guide: https://scadeone.docs.pyansys.com/version/dev/user_guide/index.html
.. _api reference: https://scadeone.docs.pyansys.com/version/dev/api/index.html
.. _examples: https://scadeone.docs.pyansys.com/version/dev/examples/index.html
| text/x-rst | null | "ANSYS, Inc." <pyansys.core@ansys.com> | null | "ANSYS, Inc." <pyansys.core@ansys.com> | null | null | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"Topic :: Software Development :: Libraries",
"Topic :: Scientific/Engineering :: Information Analysis",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Progra... | [] | null | null | <4,>=3.10 | [] | [] | [] | [
"Jinja2>=3.1.6",
"jsonschema>=4.25.1",
"platformdirs>=4.4.0",
"pythonnet>=3.0.5",
"lark>=1.3.0",
"codespell==2.2.6; extra == \"checks\"",
"ruff==0.8.2; extra == \"checks\"",
"vale==3.9.1; extra == \"checks\"",
"pre-commit==4.0.1; extra == \"checks\"",
"ansys-sphinx-theme==1.2.4; extra == \"doc\"",... | [] | [] | [] | [
"documentation, https://scadeone.docs.pyansys.com",
"issues, https://github.com/ansys/pyscadeone/issues",
"source, https://github.com/ansys/pyscadeone",
"tracker, https://github.com/ansys/pyscadeone/issues"
] | twine/6.1.0 CPython/3.12.9 | 2026-02-18T10:07:02.434083 | ansys_scadeone_core-0.8.1.tar.gz | 2,229,746 | 01/81/b385b8b1598b440ba80f69f845737e88c9e104a82005c29ac7cc481c2ca7/ansys_scadeone_core-0.8.1.tar.gz | source | sdist | null | false | 4d4c35409edd2e07b7e9810eb1a87b1a | f7b360e2c8a0faa17924557eb064a7a8260f1935e2d54875ede0b662c2e70b77 | 0181b385b8b1598b440ba80f69f845737e88c9e104a82005c29ac7cc481c2ca7 | null | [
"LICENSE"
] | 242 |
2.3 | lb-ri-utils | 0.0.1 | Utilities for working with radio interfermetric data | # lb-ri-utils
Utilities for working with radio interfermetric data
## Installation
```bash
pip install lb-ri-utils
```
## Usage
```bash
lb_ri_utils --help
```
| text/markdown | landmanbester | landmanbester <lbester@sarao.ac.za> | 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"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"hip-cargo>=0.1.3"
] | [] | [] | [] | [
"Homepage, https://github.com/landmanbester/lb-ri-utils",
"Repository, https://github.com/landmanbester/lb-ri-utils",
"Bug Tracker, https://github.com/landmanbester/lb-ri-utils/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:06:34.145278 | lb_ri_utils-0.0.1.tar.gz | 3,666 | b3/5d/4566b52d2feab8aa32b48839c30f1091ac820c252a03332f8a0af1498e13/lb_ri_utils-0.0.1.tar.gz | source | sdist | null | false | 963228f3105057185bc6274187c5c7ea | 07e0bd71f077406e3d32ae031dd765a1cf3ffcba562f6add2795163c5283db49 | b35d4566b52d2feab8aa32b48839c30f1091ac820c252a03332f8a0af1498e13 | null | [] | 275 |
2.4 | intersight | 1.0.11.2026021105 | The Python SDK for Cisco Intersight | # Cisco Intersight
Cisco Intersight is a cloud operations platform that delivers intelligent visualization, optimization, and orchestration for applications and infrastructure across your hybrid environment. With Intersight, you get all of the benefits of SaaS delivery and full lifecycle management of distributed Intersight-connected servers and third-party storage across data centers, remote sites, branch offices, and edge environments. This empowers you to analyze, update, fix, and automate your environment in ways that were not possible with prior generations’ tools. As a result, your organization can achieve significant TCO savings and deliver applications faster in support of new business initiatives.
The Cisco Intersight API is a programmatic interface that uses the REST architecture to provide access to the Intersight Management Information Model. The Intersight Python SDK is generated based on the Cisco Intersight OpenAPI 3.x specification. The latest specification can be downloaded from [here](https://intersight.com/apidocs/downloads/). The Cisco Intersight Python SDK is updated frequently to be in sync with the OpenAPI version deployed at https://intersight.com
# Getting Started
1. [ Installation ](#installation)
1.1. [ Requirements ](#requirements)
1.2. [ Install ](#install)
2. [ Authentication ](#authentication)
3. [ Creating an Object ](#creating-an-object)
4. [ Creating an Object from JSON ](#creating-an-object-from-json)
5. [ Reading Objects ](#reading-an-object)
5.1. [ Reading Objects Using a Filter ](#reading-an-object-using-a-filter)
6. [ Updating Objects ](#updating-an-object)
7. [ Deleting Objects ](#deleting-an-object)
8. [ Examples](#examples)
8.1. [ Example - Server Configuration ](#server-configuration)
8.2. [ Example - Firmware Upgrade ](#firmware-upgrade)
8.3. [ Example - OS Install ](#os-install)
9. [ Targets ](#targets)
9.1. [ Claiming a Target ](#claiming-a-target)
9.2. [ Unclaiming a Target ](#unclaiming-a-target)
9.3. [ Claiming an Appliance ](#claiming-an-appliance)
10. [ Triggering a Workflow ](#triggering-a-workflow)
11. [ Monitoring a Workflow ](#monitoring-a-workflow)
12. [ Debugging ](#debugging)
<a name="installation"></a>
## 1. Installation
<a name="requirements"></a>
### 1.1. Requirements
- Python >= 3.6
<a name="install"></a>
### 1.2. Install
- The latest intersight package can be installed using one of the following,
`pip install intersight`
`pip install git+https://github.com/CiscoDevNet/intersight-python`
`python setup.py install --user`
<a name="authentication"></a>
## 2. Authentication
- Start with creating an API Client object by specifying an API Key and an API Secret file path.
- This method also specifies which endpoint will the client connect to.
- There is no explicit login when using API Client and Secret. Every message carries the information required for authentication.
```python
import intersight
import re
import sys
def get_api_client(api_key_id, api_secret_file = None, private_key_string = None, proxy = None, endpoint="https://intersight.com"):
if api_secret_file is None and private_key_string is None:
print("Either api_secret_file or private_key_string is required to create api client")
sys.exit(1)
if api_secret_file is not None and private_key_string is not None:
print("Please provide only one among api_secret_file or private_key_string")
sys.exit(1)
if api_secret_file is not None:
with open(api_secret_file, 'r') as f:
api_key = f.read()
else:
api_key = private_key_string
if re.search('BEGIN RSA PRIVATE KEY', api_key):
# API Key v2 format
signing_algorithm = intersight.signing.ALGORITHM_RSASSA_PKCS1v15
elif re.search('BEGIN EC PRIVATE KEY', api_key):
# API Key v3 format
signing_algorithm = intersight.signing.ALGORITHM_ECDSA_MODE_DETERMINISTIC_RFC6979
configuration = intersight.Configuration(
host=endpoint,
signing_info=intersight.signing.HttpSigningConfiguration(
key_id=api_key_id,
private_key_string = api_key,
signing_scheme=intersight.signing.SCHEME_HS2019,
signing_algorithm=signing_algorithm,
hash_algorithm=intersight.signing.HASH_SHA256,
signed_headers=[
intersight.signing.HEADER_REQUEST_TARGET,
intersight.signing.HEADER_HOST,
intersight.signing.HEADER_DATE,
intersight.signing.HEADER_DIGEST,
]
)
)
# if you want to turn off certificate verification
# configuration.verify_ssl = False
# setting proxy
if proxy is not None and proxy != "":
configuration.proxy = proxy
return intersight.ApiClient(configuration)
```
Once an API Client is created, it can be used to communicate with the Intersight server.
```python
from intersight.api import boot_api
from intersight.model.boot_precision_policy import BootPrecisionPolicy
api_client = get_api_client("api_key", "~/api_secret_file_path")
# Create an api instance of the correct API type
api_instance = boot_api.BootApi(api_client)
# Create an object locally and populate the object properties
boot_precision_policy = BootPrecisionPolicy()
# Create an object in Intersight
api_response = api_instance.create_boot_precision_policy(boot_precision_policy)
```
Creating API Client with proxy and using it to communicate with the Intersight server.
```python
from intersight.api import boot_api
from intersight.model.boot_precision_policy import BootPrecisionPolicy
api_key_id = "your api_key_id"
api_secret_file = "path to your api secret file"
proxy = "your proxy"
# Creating API Client with proxy
api_client = get_api_client(api_key_id,
api_secret_file = api_secret_file
proxy = proxy)
# Create an api instance of the correct API type
api_instance = boot_api.BootApi(api_client)
# Create an object locally and populate the object properties
boot_precision_policy = BootPrecisionPolicy()
# Create an object in Intersight
api_response = api_instance.create_boot_precision_policy(boot_precision_policy)
```
<a name="creating-an-object"></a>
## 3. Creating an Object
This step helps user to create an object with the help of python intersight SDK.
In the below example we are going to create a boot precision policy.
First the instance of Model: BootPrecisionPolicy is created and then all the attributes
required to create the policy is set using the model object.
```python
from intersight.api import boot_api
from intersight.model.boot_precision_policy import BootPrecisionPolicy
from intersight.model.boot_device_base import BootDeviceBase
from intersight.model.organization_organization_relationship import OrganizationOrganizationRelationship
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
def create_boot_local_cdd():
# Creating an instance of boot_local_cdd
boot_local_cdd = BootDeviceBase(class_id="boot.LocalCdd",
object_type="boot.LocalCdd",
name="local_cdd1",
enabled=True)
return boot_local_cdd
def create_boot_local_disk():
# Creating an instance of boot_local_disk
boot_local_disk = BootDeviceBase(class_id="boot.LocalDisk",
object_type="boot.LocalDisk",
name="local_disk1",
enabled=True)
return boot_local_disk
def create_organization():
# Creating an instance of organization
organization = OrganizationOrganizationRelationship(class_id="mo.MoRef",
object_type="organization.Organization")
return organization
# Create an instance of the API class.
api_instance = boot_api.BootApi(api_client)
# Create an instance of local_cdd, local_disk, organization and list of boot_devices.
boot_local_cdd = create_boot_local_cdd()
boot_local_disk = create_boot_local_disk()
organization = create_organization()
boot_devices = [
boot_local_disk,
boot_local_cdd,
]
# BootPrecisionPolicy | The 'boot.PrecisionPolicy' resource to create.
boot_precision_policy = BootPrecisionPolicy()
# Setting all the attributes for boot_precison_policy instance.
boot_precision_policy.name = "sample_boot_policy1"
boot_precision_policy.description = "sample boot precision policy"
boot_precision_policy.boot_devices = boot_devices
boot_precision_policy.organization = organization
# example passing only required values which don't have defaults set
try:
# Create a 'boot.PrecisionPolicy' resource.
api_response = api_instance.create_boot_precision_policy(boot_precision_policy)
pprint(api_response)
except intersight.ApiException as e:
print("Exception when calling BootApi->create_boot_precision_policy: %s\n" % e)
```
<a name="creating-an-object-from-json"></a>
## 4. Creating an Object from JSON
This step helps user to create an object with the help of python intersight SDK.
In the below example we are going to create a boot precision policy.
The program will parse the input json file to fetch the json payload and use this data.
The instance of Model: BootPrecisionPolicy is created using parsed json data is as a keyword arguement.
Start with creating a json file contain the data which will be used to create boot precision policy.
Create a file data.json with the following content:
`data.json:`
```json
{
"Name":"sample_boot_policy1",
"ObjectType":"boot.PrecisionPolicy",
"ClassId":"boot.PrecisionPolicy",
"Description":"Create boot precision policy.",
"BootDevices":[
{
"ClassId":"boot.LocalCdd",
"ObjectType":"boot.LocalCdd",
"Enabled":true,
"Name":"local_cdd"
},
{
"ClassId":"boot.LocalDisk",
"ObjectType":"boot.LocalDisk",
"Enabled":true,
"Name":"local_disk"
}
],
"Organization":{
"ObjectType":"organization.Organization",
"ClassId":"mo.MoRef"
}
}
```
```python
import json
from intersight.api import boot_api
from intersight.model.boot_precision_policy import BootPrecisionPolicy
from intersight.model.boot_device_base import BootDeviceBase
from intersight.model.organization_organization_relationship import OrganizationOrganizationRelationship
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
# Create an instance of the API class.
api_instance = boot_api.BootApi(api_client)
data_json_file_path = "data.json"
with open(data_json_file_path, "r") as json_data_file:
json_data = json_data_file.read()
# Loading the json objects into python dictionary.
data = json.loads(json_data)
# BootPrecisionPolicy | The 'boot.PrecisionPolicy' resource to create.
boot_precision_policy = BootPrecisionPolicy(**data, _spec_property_naming=True,
_configuration=api_client.configuration)
# example passing only required values which don't have defaults set
try:
# Create a 'boot.PrecisionPolicy' resource.
api_response = api_instance.create_boot_precision_policy(boot_precision_policy)
pprint(api_response)
except intersight.ApiException as e:
print("Exception when calling BootApi->create_boot_precision_policy: %s\n" % e)
```
<a name="reading-an-object"></a>
## 5. Reading Objects
This step helps user to read an object with the help of python intersight SDK.
In the below example we are going to read all the results for boot precision policy.
```python
from intersight.api import boot_api
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
# Create an instance of the API class
api_instance = boot_api.BootApi(api_client)
# example passing only required values which don't have defaults set
# and optional values
try:
# Read a 'boot.PrecisionPolicy' resource.
api_response = api_instance.get_boot_precision_policy_list()
pprint(api_response)
except intersight.ApiException as e:
print("Exception when calling BootApi->get_boot_precision_policy_list: %s\n" % e)
```
<a name="reading-an-object-using-a-filter"></a>
### 5.1. Reading Objects Using a Filter
Intersight supports oData query format to return a filtered list of objects.
An example is shown below. Here we filter devices that are in connected state.
```python
from intersight.api import asset_api
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
asset_api = asset_api.AssetApi(api_client)
kwargs = dict(filter="ConnectionStatus eq 'Connected'")
# Get all device registration objects that are in connected state
api_result= api.get_asset_device_registration_list(**kwargs)
for device in api_result.results:
print(device.device_ip_address[0])
```
<a name="updating-an-object"></a>
## 6. Updating Objects
This step helps user to update an object with the help of python intersight SDK.
In the below example we are going to update a boot precision policy.
First the instance of Model: BootPrecisionPolicy is created and then all the attributes
required to update the policy is set using the model object.
The read object operation is performed to fetch:
- Moid associated to boot precision policy.
- Moid associated to organization to update the appropriate fields.
In our example the first result of the response is updated i.e. first entry among all the entries for boot precision policy is updated.
```python
from intersight.api import boot_api
from intersight.model.boot_precision_policy import BootPrecisionPolicy
from intersight.model.boot_device_base import BootDeviceBase
from intersight.model.organization_organization_relationship import OrganizationOrganizationRelationship
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
def create_boot_sdcard():
# Creating an instance of boot_hdd_device
boot_sdcard = BootDeviceBase(class_id="boot.SdCard",
object_type="boot.SdCard",
name="sdcard1",
enabled=True)
return boot_sdcard
def create_boot_iscsi():
# Creating an instance of boot_iscsi
boot_iscsi = BootDeviceBase(class_id="boot.Iscsi",
object_type="boot.Iscsi",
name="iscsi1",
enabled=True)
return boot_iscsi
def create_boot_pxe():
# Creating an instance of boot_pxe
boot_pxe = BootDeviceBase(class_id="boot.Pxe",
object_type="boot.Pxe",
name="pxe1",
enabled=True,
interface_name="pxe1")
return boot_pxe
def get_boot_precision_policy(api_client):
# Enter a context with an instance of the API client
with api_client:
# Create an instance of the API class
api_instance = boot_api.BootApi(api_client)
# example passing only required values which don't have defaults set
# and optional values
try:
# Read a 'boot.PrecisionPolicy' resource.
api_response = api_instance.get_boot_precision_policy_list()
except intersight.ApiException as e:
print("Exception when calling BootApi->get_boot_precision_policy_list: %s\n" % e)
return api_response
def create_organization(moid):
# Creating an instance of organization
organization = OrganizationOrganizationRelationship(class_id="mo.MoRef",
object_type="organization.Organization",
moid=moid)
return organization
# Create an instance of the API class.
api_instance = boot_api.BootApi(api_client)
# Getting the response for existing object.
response = get_boot_precision_policy(api_client)
# Handling error scenario if get_boot_precision_policy does not return any entry.
if not response.results:
raise NotFoundException(reason="The response does not contain any entry for boot precision policy. "
"Please create a boot precision policy and then update it.")
# Fetch the organization Moid and boot precision policy moid from the Result's first entry.
organization_moid = response.results[0].organization['moid']
moid = response.results[0].moid
# Create an instance of hdd_device, iscsi, pxe, organization and list of boot_devices.
boot_hdd_device = create_boot_sdcard()
boot_iscsi = create_boot_iscsi()
boot_pxe = create_boot_pxe()
organization = create_organization(organization_moid)
boot_devices = [
boot_hdd_device,
boot_iscsi,
boot_pxe,
]
# BootPrecisionPolicy | The 'boot.PrecisionPolicy' resource to create.
boot_precision_policy = BootPrecisionPolicy()
# Setting all the attributes for boot_precison_policy instance.
boot_precision_policy.name = "updated_boot_policy1"
boot_precision_policy.description = "Updated boot precision policy"
boot_precision_policy.boot_devices = boot_devices
boot_precision_policy.organization = organization
# example passing only required values which don't have defaults set
try:
# Update a 'boot.PrecisionPolicy' resource.
api_response = api_instance.update_boot_precision_policy(
boot_precision_policy=boot_precision_policy,
moid=moid)
pprint(api_response)
except intersight.ApiException as e:
print("Exception when calling BootApi->update_boot_precision_policy: %s\n" % e)
```
<a name="deleting-an-object"></a>
## 7. Deleting Objects
This step helps user to delete an object with the help of python intersight SDK.
In the below example we are going to delete a boot precision policy.
The read object operation is performed to fetch:
- Moid associated to boot precision policy.
In our example the first result of the response is deleted i.e. first entry among all the entries for boot precision policy is deleted.
```python
from intersight.api import boot_api
from intersight.exceptions import NotFoundException
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
def get_boot_precision_policy(api_client):
# Enter a context with an instance of the API client
with api_client:
# Create an instance of the API class
api_instance = boot_api.BootApi(api_client)
# example passing only required values which don't have defaults set
# and optional values
try:
# Read a 'boot.PrecisionPolicy' resource.
api_response = api_instance.get_boot_precision_policy_list()
except intersight.ApiException as e:
print("Exception when calling BootApi->get_boot_precision_policy_list: %s\n" % e)
return api_response
# Create an instance of the API class
api_instance = boot_api.BootApi(api_client)
# Getting the response for existing object.
response = get_boot_precision_policy(api_client)
# Handling error scenario if get_boot_precision_policy does not return any entry.
if not response.results:
raise NotFoundException(reason="The response does not contain any entry for boot precision policy. "
"Please create a boot precision policy and then delete it.")
# Fetching the moid from the Result's first entry.
moid = response.results[0].moid
# example passing only required values which don't have defaults set
try:
# Delete a 'boot.PrecisionPolicy' resource.
api_instance.delete_boot_precision_policy(moid)
print(f"Deletion for moid: %s was successful" % moid)
except intersight.ApiException as e:
print("Exception when calling BootApi->delete_boot_precision_policy: %s\n" % e)
```
<a name="examples"></a>
## 8. Examples
<a name="server-configuration"></a>
### 8.1. Example: Server Configuration
Please refer [Server Configuration](https://github.com/cisco-intersight/intersight_python_examples/blob/main/examples/server_configuration/server_configuration.py)
<a name="firmware-upgrade"></a>
### 8.2. Example: Firmware Upgrade
Please refer [Direct Firmware Upgrade](https://github.com/cisco-intersight/intersight_python_examples/blob/main/examples/firmware_upgrade/firmware_upgrade_direct.py)
Please refer [Network Firmware Upgrade](https://github.com/cisco-intersight/intersight_python_examples/blob/main/examples/firmware_upgrade/firmware_upgrade_network.py)
<a name="os-install"></a>
### 8.3. Example: OS Install
Please refer [OS Install](https://github.com/cisco-intersight/intersight_python_examples/blob/main/examples/os_install/os_install.py)
<a name="targets"></a>
## 9. Targets
<a name="claiming-a-target"></a>
### 9.1. Claiming a Target
```python
from intersight.api import asset_api
from intersight.model.asset_device_claim import AssetDeviceClaim
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
api_instance = asset_api.AssetApi(api_client)
# AssetTarget | The 'asset.Target' resource to create.
asset_target = AssetDeviceClaim()
# setting claim_code and device_id
asset_target.security_token = "2Nxxx-int"
asset_target.serial_number = "WZPxxxxxFMx"
# Post the above payload to claim a target
try:
# Create a 'asset.Target' resource.
claim_resp = api_instance.create_asset_device_claim(asset_target)
pprint(claim_resp)
except intersight.ApiException as e:
print("Exception when calling AssetApi->create_asset_device_claim: %s\n" % e)
```
<a name="unclaiming-a-target"></a>
### 9.2. Unclaiming a Target
```python
from intersight.api import asset_api
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
api_instance = asset_api.AssetApi(api_client)
# To find out all the connected devices.
kwargs = dict(filter="ConnectionStatus eq 'Connected'")
# Get all registered target.
api_result= api.get_asset_device_registration_list(**kwargs)
try:
for device in api_result.results:
# You need to provide the IP address of the target, you need to unclaim
if "10.10.10.10" in device.device_ip_address:
# Deleting the target as the same we do through api
api_instance.delete_asset_device_claim(moid=device.device_claim.moid)
except intersight.ApiException as e:
print("Exception when calling AssetApi->delete_asset_device_claim: %s\n" % e)
```
<a name="claiming-an-appliance"></a>
### 9.3. Claiming an Appliance
```python
from intersight.api import asset_api
from intersight.model.asset_target import AssetTarget
from pprint import pprint
import intersight
api_key = "api_key"
api_key_file = "~/api_key_file_path"
api_client = get_api_client(api_key, api_key_file)
api_instance = asset_api.AssetApi(api_client)
# ApplianceDeviceClaim | The 'appliance.DeviceClaim' resource to create.
appliance_device_claim = ApplianceDeviceClaim()
# setting claim_code and device_id
appliance_device_claim.username = "user1"
appliance_device_claim.password = "ChangeMe"
appliance_device_claim.hostname = "host1"
appliance_device_claim.platform_type = "UCSD"
# Post the above payload to claim a target
try:
# Create a 'appliance.DeviceClaim' resource.
claim_resp = api_instance.create_appliance_device_claim(appliance_device_claim)
pprint(claim_resp)
except intersight.ApiException as e:
print("Exception when calling AssetApi->create_appliance_device_claim: %s\n" % e)
```
<a name="triggering-a-workflow"></a>
## 10. Example : Triggering a Workflow
Please refer [Triggering a Workflow](https://github.com/cisco-intersight/intersight_python_examples/blob/main/examples/workflow/triggering_workflow.py)
<a name="monitoring-a-workflow"></a>
## 11. Example : Monitoring a Workflow
Please refer [Monitoring a Workflow](https://github.com/cisco-intersight/intersight_python_examples/blob/main/examples/workflow/monitoring_workflow.py)
<a name="debugging"></a>
## 12. Debugging
| text/markdown | Intersight API support | intersight@cisco.com | null | null | Apache License 2.0 | Cisco Intersight | [
"License :: OSI Approved :: Apache Software License",
"Natural Language :: English",
"Operating System :: OS Independent"
] | [] | https://intersight.com | null | >=3.6 | [] | [] | [] | [
"urllib3>=1.25.3",
"python-dateutil",
"pem>=19.3.0",
"pycryptodome>=3.9.0"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.9.6 | 2026-02-18T10:06:13.371925 | intersight-1.0.11.2026021105.tar.gz | 27,881,118 | 0c/af/eb021ee06ac9010eebb00923c170dac67f26ecb59edf30e5ef8b3acb9401/intersight-1.0.11.2026021105.tar.gz | source | sdist | null | false | 6d47bafb430502a089cceb66e2d59645 | 9c7e934b8b9d46fd492f40ca75eaa1cd4558a11fee4eaf659b211d307b3a1395 | 0cafeb021ee06ac9010eebb00923c170dac67f26ecb59edf30e5ef8b3acb9401 | null | [
"LICENSE"
] | 3,762 |
2.4 | resdk | 22.2.3 | Resolwe SDK for Python | ======================
Resolwe SDK for Python
======================
|build| |build-e2e| |coverage| |docs| |pypi_version| |pypi_pyversions|
.. |build| image:: https://github.com/genialis/resolwe-bio-py/workflows/ReSDK%20CI/badge.svg?branch=master
:target: https://github.com/genialis/resolwe-bio-py/actions?query=branch%3Amaster
:alt: Build Status
.. |build-e2e| image:: https://public.ci.genialis.io/buildStatus/icon/resolwe-bio-py/master
:target: https://ci.genialis.io/blue/organizations/jenkins/resolwe-bio-py/activity
:alt: Build (End-to-End) Status
.. |coverage| image:: https://img.shields.io/codecov/c/github/genialis/resolwe-bio-py/master.svg
:target: http://codecov.io/github/genialis/resolwe-bio-py?branch=master
:alt: Coverage Status
.. |docs| image:: https://readthedocs.org/projects/resdk/badge/?version=latest
:target: http://resdk.readthedocs.io/
:alt: Documentation Status
.. |pypi_version| image:: https://img.shields.io/pypi/v/resdk.svg
:target: https://pypi.python.org/pypi/resdk
:alt: Version on PyPI
.. |pypi_pyversions| image:: https://img.shields.io/pypi/pyversions/resdk.svg
:target: https://pypi.python.org/pypi/resdk
:alt: Supported Python versions
.. |pypi_downloads| image:: https://img.shields.io/pypi/dm/resdk.svg
:target: https://pypi.python.org/pypi/resdk
:alt: Number of downloads from PyPI
Resolwe SDK for Python supports interaction with Resolwe_ server
and its extension `Resolwe Bioinformatics`_. You can use it to upload
and inspect biomedical data sets, contribute annotations, run
analysis, and write pipelines.
.. _Resolwe Bioinformatics: https://github.com/genialis/resolwe-bio
.. _Resolwe: https://github.com/genialis/resolwe
Docs & Help
===========
Read the detailed description in documentation_.
.. _documentation: http://resdk.readthedocs.io/
Install
=======
Install from PyPI::
pip install resdk
If you would like to contribute to the SDK codebase, follow the
`installation steps for developers`_.
.. note::
If you are using Apple silicon you should use Python version 3.10 or higher.
.. _installation steps for developers: http://resdk.readthedocs.io/en/latest/contributing.html
Quick Start
===========
In this showcase we will download the aligned reads and their
index (BAM and BAI) from the server:
.. code-block:: python
import resdk
# Create a Resolwe object to interact with the server
res = resdk.Resolwe(url='https://app.genialis.com')
# Enable verbose logging to standard output
resdk.start_logging()
# Get sample meta-data from the server
sample = res.sample.get('resdk-example')
# Download files associated with the sample
sample.download()
Both files (BAM and BAI) have downloaded to the working directory.
Check them out. To learn more about the Resolwe SDK continue with
`Getting started`_.
.. _Getting started: http://resdk.readthedocs.io/en/latest/tutorials.html
If you do not have access to the Resolwe server, contact us at
info@genialis.com.
| text/x-rst | null | "Genialis, Inc" <dev-team@genialis.com> | 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:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) 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
(d) 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
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
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.
| bio, bioinformatics, dataflow, django, pipelines, python, resolwe, sdk | [
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Pro... | [] | null | null | <3.15,>=3.9 | [] | [] | [] | [
"aiohttp>=3.13.2",
"requests",
"urllib3>=2; python_version >= \"3.10\"",
"slumber>=0.7.1",
"wrapt",
"pytz",
"tzlocal",
"pandas<3.0.0",
"tqdm",
"openpyxl",
"xlrd",
"boto3[crt]",
"boto3-stubs[s3]",
"packaging",
"sphinx; extra == \"docs\"",
"sphinx_rtd_theme; extra == \"docs\"",
"twine;... | [] | [] | [] | [
"repository, https://github.com/genialis/resolwe-bio-py/",
"documentation, https://resdk.readthedocs.io/en/latest/"
] | twine/6.1.0 CPython/3.12.8 | 2026-02-18T10:05:36.859723 | resdk-22.2.3.tar.gz | 273,333 | c8/20/f39cdc804910cb19c687c8259ba605e75a8e3932eb1cb6e07ca132c540d4/resdk-22.2.3.tar.gz | source | sdist | null | false | 90fa12675c911efd6bc22a3e34bb6c1e | 6f733082e1cfe7612f75b4bb23185eeff75877144ed880227fe22688318ae387 | c820f39cdc804910cb19c687c8259ba605e75a8e3932eb1cb6e07ca132c540d4 | null | [
"LICENSE"
] | 601 |
2.4 | taskflow | 6.2.0 | Taskflow structured state management library. | TaskFlow
========
.. image:: https://governance.openstack.org/tc/badges/taskflow.svg
.. Change things from this point on
.. image:: https://img.shields.io/pypi/v/taskflow.svg
:target: https://pypi.org/project/taskflow/
:alt: Latest Version
.. image:: https://img.shields.io/pypi/dm/taskflow.svg
:target: https://pypi.org/project/taskflow/
:alt: Downloads
A library to do [jobs, tasks, flows] in a highly available, easy to understand
and declarative manner (and more!) to be used with OpenStack and other
projects.
* Free software: Apache license
* Documentation: https://docs.openstack.org/taskflow/latest/
* Source: https://opendev.org/openstack/taskflow
* Bugs: https://bugs.launchpad.net/taskflow/
* Release notes: https://docs.openstack.org/releasenotes/taskflow/
Join us
-------
- https://launchpad.net/taskflow
Testing and requirements
------------------------
Requirements
~~~~~~~~~~~~
Because this project has many optional (pluggable) parts like persistence
backends and engines, we decided to split our requirements into two
parts: - things that are absolutely required (you can't use the project
without them) are put into ``requirements.txt``. The requirements
that are required by some optional part of this project (you can use the
project without them) are put into our ``test-requirements.txt`` file (so
that we can still test the optional functionality works as expected). If
you want to use the feature in question (`eventlet`_ or the worker based engine
that uses `kombu`_ or the `sqlalchemy`_ persistence backend or jobboards which
have an implementation built using `kazoo`_ ...), you should add
that requirement(s) to your project or environment.
Tox.ini
~~~~~~~
Our ``tox.ini`` file describes several test environments that allow to test
TaskFlow with different python versions and sets of requirements installed.
Please refer to the `tox`_ documentation to understand how to make these test
environments work for you.
Developer documentation
-----------------------
We also have sphinx documentation in ``docs/source``.
*To build it, run:*
::
$ python setup.py build_sphinx
.. _kazoo: https://kazoo.readthedocs.io/en/latest/
.. _sqlalchemy: https://www.sqlalchemy.org/
.. _kombu: https://kombu.readthedocs.io/en/latest/
.. _eventlet: http://eventlet.net/
.. _tox: https://tox.testrun.org/
| text/x-rst | null | OpenStack <openstack-discuss@lists.openstack.org> | null | null | Apache-2.0 | null | [
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Pyth... | [] | null | null | >=3.10 | [] | [] | [] | [
"pbr>=2.0.0",
"debtcollector>=1.2.0",
"futurist>=1.2.0",
"fasteners>=0.17.3",
"networkx>=2.1.0",
"stevedore>=1.20.0",
"jsonschema>=3.2.0",
"automaton>=1.9.0",
"oslo.utils>=3.33.0",
"oslo.serialization>=2.18.0",
"tenacity>=6.0.0",
"cachetools>=2.0.0",
"pydot>=1.2.4",
"kazoo>=2.6.0; extra ==... | [] | [] | [] | [
"Homepage, https://docs.openstack.org/taskflow",
"Repository, https://opendev.org/openstack/taskflow"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-18T10:05:30.278725 | taskflow-6.2.0.tar.gz | 1,081,774 | 66/4e/9465de79d30439befc992327709830981347486c4278f52bae522fbe608f/taskflow-6.2.0.tar.gz | source | sdist | null | false | fbb6f96ce0ba7115acf23e210ec7e335 | 0a7584444da6e808582d67e70f3bd166a766a17f1aa010796e0c56b4df735f7c | 664e9465de79d30439befc992327709830981347486c4278f52bae522fbe608f | null | [
"LICENSE"
] | 5,716 |
2.4 | scheinfirmen-at | 1.4.0 | Scheinfirmen Österreich: Download and convert Austrian BMF shell company data to machine-readable formats | # Scheinfirmen Österreich
[](https://github.com/arjoma/scheinfirmen-at/actions/workflows/ci.yml)
[](https://github.com/arjoma/scheinfirmen-at/actions/workflows/update.yml)
[](https://pypi.org/project/scheinfirmen-at/)
Automatischer Download und Konvertierung der österreichischen BMF **Scheinfirmenliste**
(Liste der Scheinunternehmen) in maschinenlesbare Formate.
Die Daten werden täglich um ca. 3:15 Uhr früh (MEZ) automatisch aktualisiert.
Siehe [**Statistik & neueste Einträge**](data/STATS.md) für aktuelle Änderungen.
> [!WARNING]
> **Haftungsausschluss:** Dieses Projekt ist ein inoffizieller, automatisierter Spiegel
> der BMF-Scheinfirmenliste und steht in keiner Verbindung zum Bundesministerium für
> Finanzen (BMF) Österreich. Die Daten werden ohne jegliche Gewähr bereitgestellt.
> Weder die Vollständigkeit, Richtigkeit noch die Aktualität der Daten wird garantiert.
> Die offizielle und rechtsverbindliche Quelle ist ausschließlich die BMF-Website unter
> https://service.bmf.gv.at/service/allg/lsu/ — diese ist bei rechtlich relevanten
> Entscheidungen zu verwenden. Jegliche Haftung für Schäden, die aus der Verwendung
> dieser Daten entstehen, wird ausgeschlossen.
## Datenquelle
Das österreichische Bundesministerium für Finanzen (BMF) veröffentlicht eine Liste von
Scheinunternehmen (Unternehmen, die für Steuerbetrug oder andere illegale Aktivitäten
missbraucht werden) unter:
- **Webseite:** https://service.bmf.gv.at/service/allg/lsu/
- **CSV:** https://service.bmf.gv.at/service/allg/lsu/__Gen_Csv.asp
Die Daten stehen unter den Nutzungsbedingungen des BMF.
## Output-Dateien
Die konvertierten Daten befinden sich im `data/` Verzeichnis:
| Datei | Format | Beschreibung |
|-------|--------|--------------|
| [`scheinfirmen.csv`](https://raw.githubusercontent.com/arjoma/scheinfirmen-at/main/data/scheinfirmen.csv) | CSV (UTF-8 mit BOM) | Komma-getrennt, Excel-kompatibel ([CSVW](https://raw.githubusercontent.com/arjoma/scheinfirmen-at/main/data/scheinfirmen.csv-metadata.json)) |
| [`scheinfirmen.jsonl`](https://raw.githubusercontent.com/arjoma/scheinfirmen-at/main/data/scheinfirmen.jsonl) | JSONL | Eine JSON-Zeile pro Eintrag, erste Zeile Metadaten ([Schema](https://raw.githubusercontent.com/arjoma/scheinfirmen-at/main/data/scheinfirmen.json-schema.json)) |
| [`scheinfirmen.xml`](https://raw.githubusercontent.com/arjoma/scheinfirmen-at/main/data/scheinfirmen.xml) | XML | `<scheinfirma>`-Elemente mit Attributen ([XSD](https://raw.githubusercontent.com/arjoma/scheinfirmen-at/main/data/scheinfirmen.xsd)) |
| [`STATS.md`](data/STATS.md) | Markdown | Statistiken, neue Einträge und Verlauf |
### Datenfelder
| Feld | Typ | Beschreibung |
|------|-----|--------------|
| `name` | String | Name des Unternehmens oder der natürlichen Person |
| `anschrift` | String | Adresse (PLZ Ort, Straße Nr) |
| `veroeffentlicht` | Datum | Veröffentlichungsdatum (ISO 8601) |
| `rechtskraeftig` | Datum | Datum der Rechtskraft des Bescheids (ISO 8601) |
| `seit` | Datum\|null | Zeitpunkt als Scheinunternehmen (ISO 8601) |
| `geburtsdatum` | Datum\|null | Geburtsdatum (nur bei natürlichen Personen) |
| `fbnr` | String\|null | Firmenbuchnummer (z.B. `597821z`) |
| `uid` | String\|null | UID-Nummer (z.B. `ATU79209223`) |
| `kennziffer` | String\|null | Kennziffer des Unternehmensregisters |
Alle Datumsfelder sind im ISO-8601-Format (`YYYY-MM-DD`).
## Voraussetzungen
Dieses Projekt verwendet [uv](https://docs.astral.sh/uv/) für das Paket- und Dependency-Management. Falls Sie `uv` noch nicht installiert haben, wird dies empfohlen:
```bash
# Installation unter macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Installation unter Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```
Ausführliche Informationen finden Sie in der [uv-Dokumentation](https://docs.astral.sh/uv/getting-started/installation/).
## Direkte Ausführung (ohne Installation)
```bash
uvx scheinfirmen-at -o data/
```
Lädt das Paket von PyPI, führt es aus und cached es lokal — kein manuelles Installieren nötig (analog zu `npx`).
## Installation
```bash
pip install scheinfirmen-at
# oder mit uv:
uv add scheinfirmen-at
# oder als dauerhaftes CLI-Tool:
uv tool install scheinfirmen-at
```
## Verwendung
### Kommandozeile
```bash
# Aktuelle Daten herunterladen und in data/ konvertieren
scheinfirmen-at -o data/
# Mit ausführlicher Ausgabe
scheinfirmen-at -o data/ -v
# Lokale Datei konvertieren (kein Download)
scheinfirmen-at --input rohdaten.csv -o output/
# Hilfe
scheinfirmen-at --help
```
### Python API
```python
from scheinfirmen_at import download_csv, parse_bmf_csv, validate_records
from scheinfirmen_at.convert import write_csv, write_jsonl, write_xml
# Herunterladen und parsen
raw = download_csv()
result = parse_bmf_csv(raw)
# Validieren
validation = validate_records(result)
if not validation.ok:
for err in validation.errors:
print(f"Fehler: {err}")
# Ausgabe schreiben
write_csv(result, "scheinfirmen.csv")
write_jsonl(result, "scheinfirmen.jsonl")
write_xml(result, "scheinfirmen.xml")
# Zugriff auf einzelne Einträge
for rec in result.records:
print(rec.name, rec.uid)
```
## Entwicklung
```bash
# Repository klonen
git clone https://github.com/arjoma/scheinfirmen-at.git
cd scheinfirmen-oesterreich
# Abhängigkeiten installieren (uv)
uv sync
# Tests ausführen
uv run pytest tests/ -v
# Lint
uv run ruff check src/ tests/
# Type-Check
uv run mypy src/
```
Siehe [CHANGELOG.md](CHANGELOG.md) für die Versionshistorie.
## Technische Details
- **Abhängigkeiten:** Keine (reines Python stdlib, >= 3.10)
- **Quell-Encoding:** ISO-8859-1 (Tilde-getrennt, CRLF)
- **Output-Encoding:** UTF-8 (CSV mit BOM für Excel-Kompatibilität)
- **Validierung:** Strenge Feldvalidierung mit Fehlern und Warnungen
- **Schema-Prüfung:** Automatische Validierung gegen XSD (XML) und JSON Schema (JSONL)
- **Verifizierung:** Kreuz-Format-Prüfung (alle Formate müssen gleiche Zeilenanzahl haben)
## Lizenz
Apache License 2.0 — siehe [LICENSE](LICENSE)
Die Scheinfirmenliste selbst ist eine öffentliche Verwaltungsinformation des BMF Österreich.
| text/markdown | null | Harald Schilly <info@arjoma.at> | null | null | Apache-2.0 | austria, bmf, finanzministerium, open-data, scheinfirmen, scheinunternehmen, shell-companies, österreich | [
"Development Status :: 4 - Beta",
"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 La... | [] | null | null | >=3.10 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/arjoma/scheinfirmen-at",
"Repository, https://github.com/arjoma/scheinfirmen-at",
"Issues, https://github.com/arjoma/scheinfirmen-at/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:05:24.155481 | scheinfirmen_at-1.4.0.tar.gz | 253,532 | a1/01/80fa5931ababe1d24f1498d4fbfa793f2652e88468abbfaba8f1fc251c29/scheinfirmen_at-1.4.0.tar.gz | source | sdist | null | false | 47e7af3683e30bbe6da17c389ada6627 | 0c8f078f072aaad03a24d7e1a39766717b23015cdb33752e9389495c738e05cc | a10180fa5931ababe1d24f1498d4fbfa793f2652e88468abbfaba8f1fc251c29 | null | [
"LICENSE"
] | 252 |
2.4 | orca-pi | 2.0.0 | Python interface for the quantum chemical ORCA software package. | # OPI - ORCA Python Interface
The ORCA Python Interface (OPI) is a Python library to create input and parse output of [ORCA](https://www.faccts.de/orca/). It is designed as an open source community effort to make ORCA calculations as accessible as possible and is consistently supported by [FACCTs](https://www.faccts.de/), the co-developers of the ORCA quantum chemistry program package. Note that OPI is first introduced with ORCA 6.1 and is not compatible with earlier versions.
OPI version 2.0 and upward requires ORCA 6.1.1 as minimal ORCA version.
### Helpful Links
- **OPI:**
- Documentation (stable): https://www.faccts.de/docs/opi/2.0/docs
- Documentation (nightly): https://www.faccts.de/docs/opi/nightly/docs
- Source code: https://www.github.com/faccts/opi
- Bug reports: https://www.github.com/faccts/opi/issues
- PyPI: https://pypi.org/project/orca-pi/
- MCP: https://context7.com/faccts/opi
- **ORCA:**
- Manual: https://www.faccts.de/docs/orca/6.1/manual/
- Tutorials: https://www.faccts.de/docs/orca/6.1/tutorials/
- ORCA Forum: https://orcaforum.kofo.mpg.de/
## Installation
This package can either be installed directly from [PyPI](https://pypi.org/project/orca-pi/) with:
```
pip install orca-pi
```
or from GitHub:
```
git clone https://github.com/faccts/opi.git
cd opi
python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install .
```
More details about the installation can be found in the [documentation](https://www.faccts.de/docs/opi/2.0/docs/contents/install.html).
### ORCA and Open MPI
OPI requires ORCA and for parallel calculations also Open MPI.
Details on how to install ORCA can be found in its manual or tutorials. See [Helpful Links](#Helpful-Links).
For most modern operating system Open MPI can usually be installed directly with the systems package manager.
Otherwise, a suitable version has to be obtained and compiled from their [website](https://www.open-mpi.org/).
**Note that OPI is first introduced with ORCA 6.1 and is not compatible with earlier versions.
The minimal supported ORCA version is always stored in [ORCA_MINIMAL_VERSION](https://github.com/faccts/opi/blob/main/src/opi/__init__.py)**
## Documentation
This package comes with a set of tutorials and automatic API reference.
The files can be found in [docs/](https://github.com/faccts/opi/tree/main/docs).
We also host the documentation for the latest stable release and nightly version online.
See [Helpful Links](#Helpful-Links).
The documentation can also be built from the `docs/` folder:
```
make html
```
This requires [`uv`](https://github.com/astral-sh/uv) which by default is also installed by the `Makefile`.
## License
### Open Source License
This open source project is released publicly under the following open source license: `GPL-3.0`. This license governs all public releases of the code and allows anyone to use, modify, and distribute the project freely, in accordance with its terms.
### Proprietary License
The program, including all contributions, may also be included in our proprietary software products under a commercial license.
This enables us to:
- Combine open source and closed source components into a single product,
- Offer the project under alternative licensing terms to customers with specific commercial needs,
- Ensure open source compliance for all public parts, while simplifying license obligations in private or embedded distributions.
## Contributing
Contributions are welcome. See [How To Contribute](https://www.faccts.de/docs/opi/nightly/docs/contents/how_to_contribute.html) for details.
### Contributor License Agreement (CLA)
To maintain this licensing model, all contributors must sign our Contributor License Agreement (CLA).
This CLA is an adapted industry-standard CLA (Apache CLA) with minor modifications. By signing the CLA, you
- Retain ownership of your contributions,
- Grant us a non-exclusive license to use, sublicense, relicense and distribute your contributions under both open source and proprietary terms.
### We use a two-part CLA system:
- [Individual CLA (ICLA) for personal contributions](CLA.md),
- Corporate CLA (CCLA) for contributions made on behalf of an employer (available upon request to info@faccts.de).
## Contact
For issues or bug reports please create an [issue](https://www.github.com/faccts/opi/issues) on GitHub.
For commercial inquiries contact us directly at [info@faccts.de](mailto:info@faccts.de).
| text/markdown | null | FACCTS GmbH <info@faccts.de> | null | null | This open source project is licensed under GPL-3.0.
Please note that this program is also shipped along with proprietary FACCTs GmbH software such as ORCA under different license terms. Please contact FACCTs GmbH (https://www.faccts.de/) for further information.
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright © 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 | chemistry, hpc, interface, machine learning, orca | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: Other/Proprietary License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.11 | [] | [] | [] | [
"numpy<3,>=2.2.6",
"platformdirs<5,>=4.3.8",
"pydantic<3,>=2.11.5",
"rdkit<2026,>=2025.3.2",
"semantic-version<3,>=2.10.0"
] | [] | [] | [] | [
"Homepage, https://faccts.de",
"Documentation, https://www.faccts.de/docs/opi/nightly/docs/",
"Repository, https://github.com/faccts/opi",
"Issues, https://github.com/faccts/opi/issues",
"Changelog, https://github.com/faccts/opi/blob/main/CHANGELOG.md"
] | twine/6.2.0 CPython/3.12.3 | 2026-02-18T10:04:57.511515 | orca_pi-2.0.0.tar.gz | 13,548,354 | ce/1c/506d7a8b998dde5302c16eadc2b1eab3a30fe50a344eb4e919edaac065b5/orca_pi-2.0.0.tar.gz | source | sdist | null | false | e9d75f1f9bd3270712e90a4cea21373b | 16b4216157ede83cd7867cf4f2d3307653b033f4c7e59a2826e8a03686dac4d1 | ce1c506d7a8b998dde5302c16eadc2b1eab3a30fe50a344eb4e919edaac065b5 | null | [
"LICENSE"
] | 300 |
2.4 | graphql-http | 2.3.0 | HTTP Server for GraphQL. | # GraphQL HTTP
[](https://badge.fury.io/py/graphql-http)
[](https://pypi.org/project/graphql-http/)
[](https://opensource.org/licenses/MIT)
**[📚 Documentation](https://graphql-http.parob.com/)** | **[📦 PyPI](https://pypi.org/project/graphql-http/)** | **[🔧 GitHub](https://github.com/parob/graphql-http)**
---
A lightweight, production-ready HTTP server for GraphQL APIs built on top of Starlette/FastAPI. This server provides a simple yet powerful way to serve GraphQL schemas over HTTP with built-in support for authentication, CORS, GraphiQL integration, and more.
## Features
- 🚀 **High Performance**: Built on Starlette/ASGI for excellent async performance
- 🔐 **JWT Authentication**: Built-in JWT authentication with JWKS support
- 🌐 **CORS Support**: Configurable CORS middleware for cross-origin requests
- 🎨 **GraphiQL Integration**: Interactive GraphQL IDE for development
- 📊 **Health Checks**: Built-in health check endpoints
- 🔄 **Batch Queries**: Support for batched GraphQL operations
## Installation
```bash
uv add graphql_http
```
Or with pip:
```bash
pip install graphql_http
```
## Quick Start
### Basic Usage
```python
from graphql import GraphQLSchema, GraphQLObjectType, GraphQLField, GraphQLString
from graphql_http import GraphQLHTTP
# Define your GraphQL schema
schema = GraphQLSchema(
query=GraphQLObjectType(
name="Query",
fields={
"hello": GraphQLField(
GraphQLString,
resolve=lambda obj, info: "Hello, World!"
)
}
)
)
# Create the HTTP server
app = GraphQLHTTP(schema=schema)
# Run the server
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000)
```
### Using with graphql-api
For building GraphQL schemas, use [graphql-api](https://graphql-api.parob.com/):
```python
from graphql_api import GraphQLAPI
from graphql_http import GraphQLHTTP
api = GraphQLAPI()
@api.type(is_root_type=True)
class Query:
@api.field
def hello(self, name: str = "World") -> str:
return f"Hello, {name}!"
server = GraphQLHTTP.from_api(api)
server.run()
```
## Related Projects
- **[graphql-api](https://graphql-api.parob.com/)** - Build GraphQL schemas with decorators
- **[graphql-db](https://graphql-db.parob.com/)** - SQLAlchemy integration for database-backed APIs
- **[graphql-mcp](https://graphql-mcp.parob.com/)** - Expose GraphQL as MCP tools
See the [documentation](https://graphql-http.parob.com/) for configuration, authentication, and advanced features.
## Documentation
**Visit the [official documentation](https://graphql-http.parob.com/)** for comprehensive guides, examples, and API reference.
### Key Topics
- **[Getting Started](https://graphql-http.parob.com/docs/getting-started/)** - Quick introduction and basic usage
- **[Configuration](https://graphql-http.parob.com/docs/configuration/)** - Configure your HTTP server
- **[Authentication](https://graphql-http.parob.com/docs/authentication/)** - JWT and auth setup
- **[Testing](https://graphql-http.parob.com/docs/testing/)** - Test your GraphQL endpoints
- **[Examples](https://graphql-http.parob.com/docs/examples/)** - Real-world usage examples
- **[API Reference](https://graphql-http.parob.com/docs/api-reference/)** - Complete API documentation
## License
MIT License - see LICENSE file for details.
| text/markdown | null | Robert Parker <rob@parob.com> | null | null | MIT | GraphQL, HTTP, Server, starlette | [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | <3.13,>=3.11 | [] | [] | [] | [
"graphql-core",
"graphql-api",
"packaging",
"graphql-schema-diff",
"pyjwt[crypto]",
"starlette",
"uvicorn",
"python-multipart",
"httpx"
] | [] | [] | [] | [
"Homepage, https://gitlab.com/parob/graphql-http",
"Repository, https://gitlab.com/parob/graphql-http"
] | 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-18T10:04:47.996623 | graphql_http-2.3.0.tar.gz | 196,657 | 61/06/7bb438aeba862b276ca7d24cca27d119b115f76b45ad87f9e3096687a5f3/graphql_http-2.3.0.tar.gz | source | sdist | null | false | 69082ba87bdd1fd71bcd9467447ce4db | dfee2c3f700a378ee632390c581beb190c60ea0ee9e25084340059fc3b758d56 | 61067bb438aeba862b276ca7d24cca27d119b115f76b45ad87f9e3096687a5f3 | null | [
"LICENSE"
] | 334 |
2.4 | lwk | 0.15.0 | Liquid Wallet Kit | # Liquid Wallet Kit
A Python package to build on the [Liquid](https://blockstream.com/liquid/) network.
```python
import lwk
network = lwk.Network.mainnet()
assert(str(network) == "Liquid")
```
## Main Features
* **Watch-Only** wallet support: using Liquid descriptors, better known as
[CT descriptors](https://github.com/ElementsProject/ELIPs/blob/main/elip-0150.mediawiki).
* **PSET** based: transactions are shared and processed using the
[Partially Signed Elements Transaction](https://github.com/ElementsProject/elements/blob/1fcf0cf2323b7feaff5d1fc4c506fff5ec09132e/doc/pset.mediawiki) format.
* **Electrum** and **Esplora** [backends](https://github.com/Blockstream/electrs):
no need to run and sync a full Liquid node or rely on closed source servers.
* **Asset issuance**, **reissuance** and **burn** support: manage the lifecycle
of your Issued Assets with a lightweight client.
* **Generic multisig** wallets: create a wallet controlled by
any combination of hardware or software signers, with a user
specified quorum.
## Examples
* [List transactions](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/list_transactions.py) of a wpkh/slip77 wallet, also compute the UTXO only balance
* [Send transaction](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/send_transaction.py) of a wpkh/slip77 wallet in a regtest environment
* [Send asset](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/send_asset.py) of a wpkh/slip77 wallet in a regtest environment
* [Issue a Liquid asset](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/issue_asset.py)
* [Custom persister](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/custom_persister.py), the caller code provide how the wallet updates are persisted
* [AMP0](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/amp0.py) demonstrates Asset Management Platform version 0 integration
* [AMP2](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/amp2.py) demonstrates Asset Management platform protocol integration
* [External unblinding](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/external_unblind.py) shows how to unblind transaction data externally
* [LiquiDEX](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/liquidex.py) demonstrates Liquid decentralized swap functionality
* [Manual coin selection](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/manual_coin_selection.py) shows how to manually select coins for transactions
* [Multisig](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/multisig.py) demonstrates multisignature wallet setup and usage
* [PSET details](https://github.com/Blockstream/lwk/tree/master/lwk_bindings/tests/bindings/pset_details.py) shows how to inspect and work with Partially Signed Elements Transactions
| text/markdown; charset=UTF-8; variant=GFM | null | null | null | null | null | liquid, elements, wallet | [] | [] | null | null | null | [] | [] | [] | [] | [] | [] | [] | [
"documentation, https://docs.rs/lwk_bindings/latest/lwk_bindings/",
"homepage, https://github.com/blockstream/lwk"
] | twine/6.1.0 CPython/3.10.12 | 2026-02-18T10:04:23.368752 | lwk-0.15.0-py3-none-win_amd64.whl | 13,047,324 | 1e/c8/407fb21ac94d49c1da17d7466ef9a9f9ddca7d6cf3073edb19122ee2fe3b/lwk-0.15.0-py3-none-win_amd64.whl | py3 | bdist_wheel | null | false | 5f40f702939326f22424886bbd0aeef5 | 3407afe1db7b30834ddd58d157cf6ff19165548fbc23442e840080ec22282b9b | 1ec8407fb21ac94d49c1da17d7466ef9a9f9ddca7d6cf3073edb19122ee2fe3b | null | [] | 299 |
2.1 | pypylon | 26.1.0 | The python wrapper for the Basler pylon Camera Software Suite. | 
The official python wrapper for the Basler pylon Camera Software Suite.
Background information about usage of pypylon, programming samples and jupyter notebooks can also be found at [pypylon-samples](https://github.com/basler/pypylon-samples).
**Please Note:**
This project is offered with limited technical support by Basler AG.
You are welcome to post any questions or issues on [GitHub](https://github.com/basler/pypylon).
For additional technical assistance, please reach out to our official [Support](https://www.baslerweb.com/en/support/contact) team.
[](https://github.com/basler/pypylon/actions/workflows/main.yml)
# Getting Started
* Install [pylon](https://www.baslerweb.com/pylon)
This is strongly recommended but not mandatory. See [known issues](#known-issues) for further details.
* Install pypylon: ```pip3 install pypylon```
For more installation options and the supported systems please read the [Installation](#Installation) paragraph.
* Look at [samples/grab.py](https://github.com/basler/pypylon/blob/master/samples/grab.py) or use the following snippet:
```python
from pypylon import pylon
camera = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateFirstDevice())
camera.Open()
# demonstrate some feature access
new_width = camera.Width.Value - camera.Width.Inc
if new_width >= camera.Width.Min:
camera.Width.Value = new_width
numberOfImagesToGrab = 100
camera.StartGrabbingMax(numberOfImagesToGrab)
while camera.IsGrabbing():
grabResult = camera.RetrieveResult(5000, pylon.TimeoutHandling_ThrowException)
if grabResult.GrabSucceeded():
# Access the image data.
print("SizeX: ", grabResult.Width)
print("SizeY: ", grabResult.Height)
img = grabResult.Array
print("Gray value of first pixel: ", img[0, 0])
grabResult.Release()
camera.Close()
```
## Getting Started with pylon Data Processing
* pypylon additionally supports the pylon Data Processing API extension.
* The [pylon Workbench](https://docs.baslerweb.com/overview-of-the-workbench) allows you to create image processing designs using a graphical editor.
* Hint: The [pylondataprocessing_tests](https://github.com/basler/pypylon/blob/master/tests/pylondataprocessing_tests) can optionally be used as a source of information about the syntax of the API.
* Look at [samples/dataprocessing_barcode.py](https://github.com/basler/pypylon/blob/master/samples/dataprocessing_barcode.py) or use the following snippet:
```python
from pypylon import pylondataprocessing
import os
resultCollector = pylondataprocessing.GenericOutputObserver()
recipe = pylondataprocessing.Recipe()
recipe.Load('dataprocessing_barcode.precipe')
recipe.RegisterAllOutputsObserver(resultCollector, pylon.RegistrationMode_Append);
recipe.Start()
for i in range(0, 100):
if resultCollector.GetWaitObject().Wait(5000):
result = resultCollector.RetrieveResult()
# Print the barcodes
variant = result["Barcodes"]
if not variant.HasError():
# Print result data
for barcodeIndex in range(0, variant.NumArrayValues):
print(variant.GetArrayValue(barcodeIndex).ToString())
else:
print("Error: " + variant.GetErrorDescription())
else:
print("Result timeout")
break
recipe.Unload()
```
# Update your code to pypylon >= 3.0.0
The current pypylon implementation allows direct feature assignment:
```python
cam.Gain = 42
```
This assignment style is deprecated with pypylon 3.0.0, as it prevents full typing support for pypylon.
The recommended assignment style is now:
```python
cam.Gain.Value = 42
```
To identify the locations in your code that have to be updated, run with enabled warnings:
`PYTHONWARNINGS=default python script.py`
# Installation
## Prerequisites
* Installed [pylon](https://www.baslerweb.com/pylon)
For the binary installation this is not mandatory but strongly recommended. See [known issues](#known-issues) for further details.
* Installed [python](https://www.python.org/) with [pip](https://pip.pypa.io/en/stable/)
* Installed [CodeMeter Runtime](https://www.wibu.com/support/user/user-software.html) when you want to use pylon vTools and the pylon Data Processing API extension on your platform.
## pylon OS Versions and Features
Please note that the pylon Camera Software Suite may support different operating system versions and features than pypylon.
For latest information on pylon refer to: https://www.baslerweb.com/en/software/pylon/
In addition, check the release notes of your pylon installation.
For instance:
* pylon Camera Software Suite 8.1.0 supports Windows 10/11 64 bit, Linux x86_64 and Linux aarch64 with glibc version >= 2.31 or newer,
macOS Sonoma or newer.
* pylon vTools are supported on pylon 7.0.0 and newer.
* pylon vTools are supported on pypylon 3.0 and newer only on Windows 10/11 64 bit, Linux x86_64 and Linux aarch64.
* For pylon vTools that require a license refer to: https://www.baslerweb.com/en/software/pylon-vtools/
* CXP-12: To use CXP with pypylon >= 4.0.0 you need to install the CXP GenTL producer and drivers using the pylon Camera Software Suite setup.
* For accessing Basler 3D cameras, e.g. Basler blaze, installation of pylon Camera Software Suite 8.1.0
and the latest pylon Supplementary Package for blaze is required.
## Binary Installation
The easiest way to get pypylon is to install a prebuild wheel.
Binary releases for most architectures are available on [pypi](https://pypi.org)**.
To install pypylon open your favourite terminal and run:
```pip3 install pypylon```
The following versions are available on pypi:
| | 3.9 | 3.10 | 3.11 | 3.12 | 3.13 |
|----------------|-----|------|------|------|------|
| Windows 64bit | x | x | x | x | x |
| Linux x86_64* | x | x | x | x | x |
| Linux aarch64* | x | x | x | x | x |
| macOS x86_64** | x | x | x | x | x |
| macOS arm64** | x | x | x | x | x |
> Additional Notes on binary packages:
> * (*) The linux 64bit binaries are manylinux_2_31 conformant.
This is roughly equivalent to a minimum glibc version >= 2.31.
:warning: You need at least pip 20.3 to install them.
> * (**) macOS binaries are built for macOS >= 14.0 (Sonoma)
## Installation from Source
Building the pypylon bindings is supported and tested on Windows, Linux and macOS
You need a few more things to compile pypylon:
* An installation of pylon SDK for your platform
* A compiler for your system (Visual Studio on Windows, gcc on linux, xCode commandline tools on macOS)
* Python development files (e.g. `sudo apt install python-dev` on linux)
* [swig](http://www.swig.org) 4.3
* For all 64bit platforms you can install the tool via `pip install "swig==4.3"`
To build pypylon from source:
```console
git clone https://github.com/basler/pypylon.git
cd pypylon
pip install .
```
If pylon SDK is not installed in a default location you have to specify the location from the environment
* on Linux: `export PYLON_ROOT=<installation directory of pylon SDK>`
* on macOS: `export PYLON_FRAMEWORK_LOCATION=<framework base folder that contains pylon.framework>`
# Development
Pull requests to pypylon are very welcome. To help you getting started with pypylon improvements, here are some hints:
## Starting Development
```console
python setup.py develop
```
This will "link" the local pypylon source directory into your python installation. It will not package the pylon libraries and always use the installed pylon.
After changing pypylon, execute `python setup.py build` and test...
## Running Unit Tests
> NOTE: The unit tests try to import `pypylon....`, so they run against the *installed* version of pypylon.
```console
pytest tests/....
```
# Known Issues
* For USB 3.0 cameras to work on Linux, you need to install appropriate udev rules.
The easiest way to get them is to install the official [pylon](http://www.baslerweb.com/pylon) package.
| text/markdown | Basler AG | oss@baslerweb.com | null | null | Other/Proprietary License | null | [
"License :: Other/Proprietary License",
"Programming Language :: C++",
"Operating System :: Microsoft :: Windows :: Windows 7",
"Operating System :: Microsoft :: Windows :: Windows 8",
"Operating System :: Microsoft :: Windows :: Windows 10",
"Operating System :: Microsoft :: Windows :: Windows 11",
"Op... | [] | https://github.com/basler/pypylon | null | null | [] | [] | [] | [] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.13 | 2026-02-18T10:04:13.138430 | pypylon-26.1.0-cp39-abi3-win_amd64.whl | 104,795,391 | 76/44/5ad55db76c0c5a6a80e096953d794f1ae943eeb5880df5509b6b66d7e742/pypylon-26.1.0-cp39-abi3-win_amd64.whl | cp39 | bdist_wheel | null | false | e03491624e598555e6f654b6d37299d0 | 236bf7cd1681eb1fd888c8f22a521710c31911f4b224bcfa796feecb06f44a6e | 76445ad55db76c0c5a6a80e096953d794f1ae943eeb5880df5509b6b66d7e742 | null | [] | 2,607 |
2.4 | yougile-api | 1.2.0 | Yougile API models | # Yougile API для Python
## Информация о библиотеке
Библиотека является разработкой стороннего разработчика для удобства обращения к Yougile API.
## Установка
Если вы устанавливаете вручную, перед использованием библиотеки, необходимо установить следующее:
```console
> pip install pydantic
> pip install requests
```
Если вы устанавливаете из PyPI, то эти библиотеки устанавливаются автоматически:
```console
> pip install yougile-api
```
## Wiki
У моделей есть правила:
1. Название моделей полностью копируют URL этой модели на официальном API.
2. У всех моделей есть описания параметров, краткого описания из официального API и ссылка на запрос.
3. Названия параметров модели и их типизация идентичны параметрам из официального API (За исключением параметра ```token```)
## Возможности
Вы можете использовать токен не только к отдельным моделям, но и к самой функции запроса:
```python
import requests
import yougile
import yougile.models as models
def yougile_get(model: yougile.BaseModel) -> requests.Response:
return yougile.query(model,token="TOKEN")
model = models.ChatMessageController_search(chatId="12324")
response = yougile_get(model)
for msg in response.json()['content']:
print(msg['text'])
```
## Примеры
### 1. Получаем список доступных компаний
```python
import yougile # Импортируем библиотеку
import yougile.models as models # Импортируем модели
model = models.AuthKeyController_companiesList(login="USERNAME",password="PASSWORD") # Указываем модель запроса листа компаний через авторизацию
response = yougile.query(model) # Делаем запрос на сервер
print(response.text) # Получаем ответ
```
### 2. Создаем токен
```python
import yougile
import yougile.models as models
model = models.AuthKeyController_create(login="USERNAME",password="PASSWORD",companyId="12345")
response = yougile.query(model)
print(response.json()['key'])
```
### 3. Получаем историю сообщений
```python
import yougile
import yougile.models as models
model = models.ChatMessageController_search(token="TOKEN",chatId="12324")
response = yougile.query(model)
for msg in response.json()['content']:
print(msg['text'])
```
## Версии
### v1.0.0
* Созданы первые модели
* Создано подключение к серверу API
### v1.0.1
* Исправлены модели
* Исправлены комментарии
### v1.1.0
* Добавлены новые модели: `CompanyController_get`, `CompanyController_update`, `FileController_uploadFile`,
`TaskController_getChatSubscribers`, `TaskController_updateChatSubscribers`
* Добавлена возможность загрузки файла через `FileController_uploadFile`
* Добавлено CI/CD
* Исправлены модели `TaskController_get` и `TaskController_update` (Спасибо [XTerris](https://github.com/XTerris))
* Исправлены модели в документации
* Улучшена документация: Заменена на Google Docstring
* Выполнен рефакторинг кода
### v1.2.0
* Добавлены модели `CrmContactPersonsController_create` и
`CrmExternalIdController_findContactByExternalId`.
* Изменена лицензия в файле `LICENSE` с `GNU GPL v3.0`
на `MIT` (Спасибо [XTerris](https://github.com/XTerris)).
| text/markdown | null | txello <txello7@proton.me> | null | null | null | null | [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"pydantic",
"requests"
] | [] | [] | [] | [
"Homepage, https://github.com/txello/YouGile",
"Issues, https://github.com/txello/YouGile/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:04:11.702090 | yougile_api-1.2.0.tar.gz | 14,121 | d8/63/76d9877cc4c3f7bccf45fbdb0dd2e229316a445c78eaaee172c7a853fe7d/yougile_api-1.2.0.tar.gz | source | sdist | null | false | 1c39c12caac824661584287240668610 | c5677c7e13abf5c9f89195325072c511bd5927569ef3a5891d699aac06acce9d | d86376d9877cc4c3f7bccf45fbdb0dd2e229316a445c78eaaee172c7a853fe7d | null | [
"LICENSE"
] | 262 |
2.4 | prompt-ast | 0.2.5 | Parse free-form human prompts into a canonical Prompt AST (structured JSON/YAML). | # 📦 `prompt-ast` [](https://pepy.tech/projects/prompt-ast)
> **Parse human prompts into a canonical, structured Prompt AST.**
`prompt-ast` is a lightweight Python library that converts free-form human prompts into a **Prompt Abstract Syntax Tree (AST)** — a clean, machine-friendly representation that captures intent, constraints, and expected output.
It treats prompts as **first-class artifacts**, not just strings.
---
## ✨ Why `prompt-ast`?
Modern LLM workflows rely heavily on prompts — but prompts today are:
* unstructured text
* hard to analyze or validate
* difficult to reuse or compare
* tightly coupled to specific tools or models
`prompt-ast` introduces a **foundational layer** that sits *before* agents, chains, or LLM calls:
```
Human Prompt
↓
Prompt AST (this library)
↓
LLM / Agent / Tooling
```
By normalizing prompts into a canonical structure, you unlock better tooling, governance, and reuse — without forcing opinions on how prompts are stored or executed.
---
## 🧠 What is a Prompt AST?
Inspired by compiler ASTs, a **Prompt AST** is an abstract, structured representation of a prompt.
Example:
**Input**
```text
Act as a CTO. Be concise. Explain risks of migrating MySQL to RDS.
```
**Output (JSON)**
```json
{
"version": "0.1",
"raw": "Act as a CTO. Be concise. Explain risks of migrating MySQL to RDS.",
"role": "CTO",
"context": null,
"task": "Explain risks of migrating MySQL to RDS",
"constraints": [
"Be concise"
],
"assumptions": [],
"ambiguities": [],
"output_spec": {
"format": null,
"structure": [],
"language": null
},
"metadata": {
"extracted_by": "heuristic",
"confidence": 0.55
}
}
```
---
## 🚀 Features
* ✅ Parse free-form prompts into a canonical AST
* ✅ Heuristic (offline) parsing — no API key required
* ✅ Optional LLM-assisted parsing (pluggable)
* ✅ JSON and YAML export
* ✅ CLI and Python API
* ✅ Minimal, extensible schema
* ✅ Stateless by design (you own storage, versioning, governance)
---
## 📦 Installation
```bash
pip install prompt-ast
```
Optional extras:
```bash
pip install prompt-ast[yaml] # YAML export
pip install prompt-ast[openai] # OpenAI-compatible LLM parsing
pip install prompt-ast[all]
```
---
## 🧪 Quick Start (Python)
```python
from prompt_ast import parse_prompt
ast = parse_prompt(
"Act as a senior backend architect. Be concise. Explain system design trade-offs.",
mode="heuristic"
)
print(ast.to_json())
```
---
## � Documentation
For more detailed documentation, see the [docs](./docs/) folder:
- **[Concepts](./docs/concepts.md)** — Core concepts and terminology
- **[CLI Usage](./docs/cli.md)** — Command-line interface reference
- **[Examples](./docs/examples.md)** — Real-world usage examples
---
## �🖥 CLI Usage
```bash
prompt-ast normalize \
"Act as a CTO. Be concise." \
--mode heuristic \
--format json
```
LLM-assisted mode (optional):
```bash
export OPENAI_API_KEY=...
prompt-ast normalize \
"Design a scalable data pipeline." \
--mode hybrid \
--use-openai
```
---
## 🧩 Design Principles
`prompt-ast` is intentionally **lean**:
* ❌ No storage
* ❌ No prompt registry
* ❌ No agent framework
* ❌ No vendor lock-in
Instead, it provides a **clean abstraction** that other systems can build on.
This makes it ideal for:
* internal tooling
* prompt governance pipelines
* evaluation frameworks
* AI platform teams
* research & experimentation
---
## 🛣 Roadmap / Future Scope
The current version focuses on **core normalization**. Planned and possible future directions include:
### Near-term
* Improved heuristic extraction accuracy
* Better ambiguity detection
* Schema refinements based on real-world usage
* More LLM adapters (Anthropic, local models)
### Mid-term (opt-in tooling)
* Prompt linting (missing task, conflicting constraints)
* Prompt diffs (semantic-ish comparison)
* Prompt fingerprints / hashes
* Validation rules
### Long-term (out of scope for core)
* Prompt registries
* Governance workflows
* Evaluation frameworks
* UI tooling
> These are intentionally *not* bundled into the core library.
---
## 🤝 Contributing
Contributions are very welcome — especially in these areas:
* Improving heuristic parsing
* Adding test fixtures (real-world prompts)
* Refining the schema
* Documentation improvements
* CLI UX enhancements
### Getting started
```bash
git clone https://github.com/<your-username>/prompt-ast.git
cd prompt-ast
poetry install
poetry run pytest
```
Please:
* keep changes small and focused
* add tests for behavior changes
* avoid introducing heavy dependencies
Open an issue before large changes — discussion is encouraged.
If you’re new to the project, check issues labeled **good first issue** —
they are small, well-scoped tasks ideal for first-time contributors.
---
## 📜 License
**MIT License**
This project is released under the MIT License, which means:
* ✅ Free for personal and commercial use
* ✅ Permissive and business-friendly
* ✅ Attribution required
* ❌ No warranty provided
Perfect for individual contributors and early open-source traction.
(See `LICENSE` file for full text.)
---
## 🌱 Why this project exists
Prompts are becoming one of the most important interfaces in modern software — yet they lack the basic tooling we take for granted in other domains.
`prompt-ast` is an attempt to provide a **small, composable foundation** that the ecosystem can build upon.
If that resonates with you, you’re in the right place.
---
## ⭐ Support the project
If you find this useful:
* ⭐ Star the repo
* 🐛 Report issues
* 💡 Share ideas
* 🧑💻 Contribute code
| text/markdown | Chvrr | null | null | null | MIT | null | [
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14"
] | [] | https://github.com/chvr4ai-hub/prompt-ast | null | >=3.11 | [] | [] | [] | [
"pydantic<3.0,>=2.7",
"typer<1.0,>=0.12",
"rich<15.0,>=13.7",
"pyyaml<7.0.0,>=6.0.3",
"httpx<0.29.0,>=0.28.1",
"pyyaml<7.0,>=6.0.1; extra == \"yaml\"",
"httpx<1.0,>=0.27; extra == \"openai\"",
"pyyaml<7.0,>=6.0.1; extra == \"all\"",
"httpx<1.0,>=0.27; extra == \"all\""
] | [] | [] | [] | [
"Homepage, https://github.com/chvr4ai-hub/prompt-ast",
"Repository, https://github.com/chvr4ai-hub/prompt-ast",
"Documentation, https://github.com/chvr4ai-hub/prompt-ast/tree/main/docs/index.md",
"Issues, https://github.com/chvr4ai-hub/prompt-ast/issues"
] | poetry/2.2.1 CPython/3.11.9 Darwin/24.6.0 | 2026-02-18T10:04:03.895272 | prompt_ast-0.2.5.tar.gz | 16,376 | 7b/ed/648de8e9394ec6a225b5a506c90dc1c2d492e68426a055dea75a43bf28be/prompt_ast-0.2.5.tar.gz | source | sdist | null | false | 07e24a58d1730b7c0bca14c1203115ea | 4c191af00bc7f76acf2acc946ce4dece48c4859a80b50a07595b68969b245b4c | 7bed648de8e9394ec6a225b5a506c90dc1c2d492e68426a055dea75a43bf28be | null | [] | 248 |
2.4 | webscout | 2026.2.18 | Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more | <div align="center">
<a href="https://github.com/OEvortex/Webscout">
<img src="https://img.shields.io/badge/WebScout-Ultimate%20Toolkit-blue?style=for-the-badge&logo=python&logoColor=white" alt="WebScout Logo">
</a>
<h1>Webscout</h1>
<p><strong>Your All-in-One Python Toolkit for Web Search, AI Interaction, Digital Utilities, and More</strong></p>
<p>
Access diverse search engines, cutting-edge AI models, temporary communication tools, media utilities, developer helpers, and powerful CLI interfaces – all through one unified library.
</p>
<!-- Badges -->
<p>
<a href="https://pypi.org/project/webscout/"><img src="https://img.shields.io/pypi/v/webscout.svg?style=flat-square&logo=pypi&label=PyPI" alt="PyPI Version"></a>
<a href="https://pepy.tech/project/webscout"><img src="https://static.pepy.tech/badge/webscout/month?style=flat-square" alt="Monthly Downloads"></a>
<a href="https://pepy.tech/project/webscout"><img src="https://static.pepy.tech/badge/webscout?style=flat-square" alt="Total Downloads"></a>
<a href="#"><img src="https://img.shields.io/pypi/pyversions/webscout?style=flat-square&logo=python" alt="Python Version"></a>
<a href="https://deepwiki.com/OEvortex/Webscout"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
</p>
</div>
<hr/>
## 📋 Table of Contents
- [🌟 Key Features](#-features)
- [⚙️ Installation](#️-installation)
- [🖥️ Command Line Interface](#️-command-line-interface)
- [📚 Documentation Hub](docs/README.md)
- [🔄 OpenAI-Compatible API Server](docs/openai-api-server.md)
- [🕸️ Scout: HTML Parser & Web Crawler](docs/scout.md)
- [🎭 Awesome Prompts Manager](docs/awesome-prompts.md)
- [🔗 GitAPI: GitHub Data Extraction](docs/gitapi.md)
- [🤖 AI Models and Voices](#-ai-models-and-voices)
- [💬 AI Chat Providers](#-ai-chat-providers)
- [👨💻 Advanced AI Interfaces](#-advanced-ai-interfaces)
- [🤝 Contributing](#-contributing)
- [🙏 Acknowledgments](#-acknowledgments)
<hr/>
> [!IMPORTANT]
> **Webscout supports three types of compatibility:**
>
> - **Native Compatibility:** Webscout's own native API for maximum flexibility
> - **OpenAI Compatibility:** Use providers with OpenAI-compatible interfaces
> - **Local LLM Compatibility:** Run local models with OpenAI-compatible servers
>
> Choose the approach that best fits your needs! For OpenAI compatibility, check the [OpenAI Providers README](webscout/Provider/OPENAI/README.md) or see the [OpenAI-Compatible API Server](#-openai-compatible-api-server) section below.
> [!NOTE]
> Webscout supports over 90 AI providers including: LLAMA, C4ai, Copilot, HuggingFaceChat, PerplexityLabs, DeepSeek, WiseCat, GROQ, OPENAI, GEMINI, DeepInfra, Meta, YEPCHAT, TypeGPT, ChatGPTClone, ExaAI, Claude, Anthropic, Cloudflare, AI21, Cerebras, and many more. All providers follow similar usage patterns with consistent interfaces.
<div align="center">
<!-- Social/Support Links -->
<p>
<a href="https://t.me/OEvortexAI"><img alt="Telegram Group" src="https://img.shields.io/badge/Telegram%20Group-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white"></a>
<a href="https://t.me/ANONYMOUS_56788"><img alt="Developer Telegram" src="https://img.shields.io/badge/Developer%20Contact-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white"></a>
<a href="https://youtube.com/@OEvortex"><img alt="YouTube" src="https://img.shields.io/badge/YouTube-FF0000?style=for-the-badge&logo=youtube&logoColor=white"></a>
<a href="https://www.linkedin.com/in/oe-vortex-29a407265/"><img alt="LinkedIn" src="https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white"></a>
<a href="https://www.instagram.com/oevortex/"><img alt="Instagram" src="https://img.shields.io/badge/Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white"></a>
<a href="https://buymeacoffee.com/oevortex"><img alt="Buy Me A Coffee" src="https://img.shields.io/badge/Buy%20Me%20A%20Coffee-FFDD00?style=for-the-badge&logo=buymeacoffee&logoColor=black"></a>
</p>
</div>
<hr/>
## 🚀 Features
<details open>
<summary><b>Search & AI</b></summary>
<p>
- **Comprehensive Search:** Access multiple search engines including DuckDuckGo, Yep, Bing, Brave, Yahoo, Yandex, Mojeek, and Wikipedia for diverse search results ([Search Documentation](docs/search.md))
- **AI Powerhouse:** Access and interact with various AI models through three compatibility options:
- **Native API:** Use Webscout's native interfaces for providers like OpenAI, Cohere, Gemini, and many more
- **[OpenAI-Compatible Providers](webscout/Provider/OPENAI/README.md):** Seamlessly integrate with various AI providers using standardized OpenAI-compatible interfaces
- **Local LLMs:** Run local models with OpenAI-compatible servers (see [Inferno documentation](docs/inferno.md))
- **[AI Search](webscout/Provider/AISEARCH/README.md):** AI-powered search engines with advanced capabilities
- **[OpenAI-Compatible API Server](docs/openai-api-server.md):** Run a local API server that serves any Webscout provider through OpenAI-compatible endpoints
- **[Python Client API](docs/client.md):** Use Webscout providers directly in Python with OpenAI-compatible format
</p>
</details>
<details open>
<summary><b>Media & Content Tools</b></summary>
<p>
- **[YouTube Toolkit](webscout/Extra/YTToolkit/README.md):** Advanced YouTube video and transcript management with multi-language support
- **[Text-to-Speech (TTS)](webscout/Provider/TTS/README.md):** Convert text into natural-sounding speech using multiple AI-powered providers
- **[Text-to-Image](webscout/Provider/TTI/README.md):** Generate high-quality images using a wide range of AI art providers
- **[Weather Tools](docs/weather.md):** Retrieve detailed weather information for any location
</p>
</details>
<details open>
<summary><b>Developer Tools</b></summary>
<p>
- **[GitAPI](docs/gitapi.md):** Powerful GitHub data extraction toolkit without authentication requirements for public data
- **[SwiftCLI](docs/swiftcli.md):** A powerful and elegant CLI framework for beautiful command-line interfaces
- **[LitPrinter](docs/litprinter.md):** Styled console output with rich formatting and colors
- **[LitAgent](docs/litagent.md):** Modern user agent generator that keeps your requests undetectable
- **[Scout](docs/scout.md):** Advanced web parsing and crawling library with intelligent HTML/XML parsing
- **[GGUF Conversion](webscout/Extra/gguf.md):** Convert and quantize Hugging Face models to GGUF format
- **[Utility Decorators](docs/decorators.md):** Easily measure function execution time (`timeIt`) and add retry logic (`retry`) to any function
- **[Stream Sanitization Utilities](docs/sanitize.md):** Advanced tools for cleaning, decoding, and processing data streams
- **[Command Line Interface](docs/cli.md):** Comprehensive CLI for all search engines and utilities
</p>
</details>
<details open>
<summary><b>Privacy & Utilities</b></summary>
<p>
- **[Tempmail](webscout/Extra/tempmail/README.md) & Temp Number:** Generate temporary email addresses and phone numbers
- **[Awesome Prompts Manager](docs/awesome-prompts.md):** Curated collection of system prompts for specialized AI personas with comprehensive management capabilities
</p>
</details>
<hr/>
## ⚙️ Installation
Webscout supports multiple installation methods to fit your workflow:
### 📦 Standard Installation
```bash
# Install from PyPI
pip install -U webscout
# Install with API server dependencies
pip install -U "webscout[api]"
# Install with development dependencies
pip install -U "webscout[dev]"
```
### ⚡ UV Package Manager (Recommended)
[UV](https://github.com/astral-sh/uv) is a fast Python package manager. Webscout has full UV support:
```bash
# Install UV first (if not already installed)
pip install uv
# Install Webscout with UV
uv add webscout
# Install with API dependencies
uv add "webscout[api]"
# Run Webscout directly with UV (no installation needed)
uv run webscout --help
# Run with API dependencies
uv run webscout --extra api webscout-server
# Install as a UV tool for global access
uv tool install webscout
# Use UV tool commands
webscout --help
webscout-server
```
### 🔧 Development Installation
```bash
# Clone the repository
git clone https://github.com/OEvortex/Webscout.git
cd Webscout
# Install in development mode with UV
uv sync --extra dev --extra api
# Or with pip
pip install -e ".[dev,api]"
# Or with uv pip
uv pip install -e ".[dev,api]"
```
### 🐳 Docker Installation
```bash
# Pull and run the Docker image
docker pull OEvortex/webscout:latest
docker run -it OEvortex/webscout:latest
```
### 📱 Quick Start Commands
After installation, you can immediately start using Webscout:
```bash
# Check version
webscout version
# Search the web
webscout text -k "python programming"
# Start API server
webscout-server
# Get help
webscout --help
```
<hr/>
## 🖥️ Command Line Interface
Webscout provides a comprehensive command-line interface with support for multiple search engines and utilities. You can use it in multiple ways:
### 🚀 Direct Commands (Recommended)
After installing with `uv tool install webscout` or `pip install webscout`:
```bash
# Get help and list all commands
webscout --help
# Show version
webscout version
# Start API server
webscout-server
# Web search commands
webscout text -k "python programming" # DuckDuckGo text search
webscout images -k "mountain landscape" # DuckDuckGo image search
webscout news -k "AI breakthrough" -t w # News from last week
webscout weather -l "New York" # Weather information
webscout translate -k "Hello" -to es # Translation
# Alternative search engines
webscout yahoo_text -k "machine learning" -r us # Yahoo search
webscout bing_text -k "climate change" # Bing search
webscout yep_text -k "latest news" # Yep search
# Search with advanced options
webscout images -k "cat" --size large --type-image photo --license-image any
webscout maps -k "coffee shop" --city "New York" --radius 5
```
### 🔧 UV Run Commands (No Installation Required)
```bash
# Run directly with UV (downloads and runs automatically)
uv run webscout --help
uv run webscout text -k "latest news"
uv run --extra api webscout-server
```
### 📦 Python Module Commands
```bash
# Traditional Python module execution
python -m webscout --help
python -m webscout text -k "search query"
python -m webscout-server
```
### 🌐 Supported Search Providers
Webscout CLI supports multiple search backends:
- **DuckDuckGo** (default): `text`, `images`, `videos`, `news`, `answers`, `maps`, `translate`, `suggestions`, `weather`
- **Yahoo**: `yahoo_text`, `yahoo_images`, `yahoo_videos`, `yahoo_news`, `yahoo_answers`, `yahoo_maps`, `yahoo_translate`, `yahoo_suggestions`, `yahoo_weather`
- **Bing**: `bing_text`, `bing_images`, `bing_news`, `bing_suggestions`
- **Yep**: `yep_text`, `yep_images`, `yep_suggestions`
For detailed command reference and all available options, see [CLI Documentation](docs/cli.md).
<hr/>
## 🤖 AI Models and Voices
Webscout provides easy access to a wide range of AI models and voice options.
<details open>
<summary><b>LLM Models</b></summary>
<p>
Access and manage Large Language Models with Webscout's model utilities.
```python
from webscout import model
from rich import print
# List all available LLM models
all_models = model.llm.list()
print(f"Total available models: {len(all_models)}")
# Get a summary of models by provider
summary = model.llm.summary()
print("Models by provider:")
for provider, count in summary.items():
print(f" {provider}: {count} models")
# Get models for a specific provider
provider_name = "PerplexityLabs"
available_models = model.llm.get(provider_name)
print(f"\n{provider_name} models:")
if isinstance(available_models, list):
for i, model_name in enumerate(available_models, 1):
print(f" {i}. {model_name}")
else:
print(f" {available_models}")
```
</p>
</details>
<details open>
<summary><b>TTS Voices</b></summary>
<p>
Access and manage Text-to-Speech voices across multiple providers.
```python
from webscout import model
from rich import print
# List all available TTS voices
all_voices = model.tts.list()
print(f"Total available voices: {len(all_voices)}")
# Get a summary of voices by provider
summary = model.tts.summary()
print("\nVoices by provider:")
for provider, count in summary.items():
print(f" {provider}: {count} voices")
# Get voices for a specific provider
provider_name = "ElevenlabsTTS"
available_voices = model.tts.get(provider_name)
print(f"\n{provider_name} voices:")
if isinstance(available_voices, dict):
for voice_name, voice_id in list(available_voices.items())[:5]: # Show first 5 voices
print(f" - {voice_name}: {voice_id}")
if len(available_voices) > 5:
print(f" ... and {len(available_voices) - 5} more")
```
</p>
</details>
<hr/>
## 💬 AI Chat Providers
Webscout offers a comprehensive collection of AI chat providers, giving you access to various language models through a consistent interface.
### Popular AI Providers
<div class="provider-table">
| Provider | Description | Key Features |
| ---------------- | ------------------------ | ---------------------------------- |
| `OPENAI` | OpenAI's models | GPT-3.5, GPT-4, tool calling |
| `GEMINI` | Google's Gemini models | Web search capabilities |
| `Meta` | Meta's AI assistant | Image generation, web search |
| `GROQ` | Fast inference platform | High-speed inference, tool calling |
| `LLAMA` | Meta's Llama models | Open weights models |
| `DeepInfra` | Various open models | Multiple model options |
| `Cohere` | Cohere's language models | Command models |
| `PerplexityLabs` | Perplexity AI | Web search integration |
| `YEPCHAT` | Yep.com's AI | Streaming responses |
| `ChatGPTClone` | ChatGPT-like interface | Multiple model options |
| `TypeGPT` | TypeChat models | Multiple model options |
</div>
<details>
<summary><b>Example: Using Meta AI</b></summary>
<p>
```python
from webscout import Meta
# For basic usage (no authentication required)
meta_ai = Meta()
# Simple text prompt
response = meta_ai.chat("What is the capital of France?")
print(response)
# For authenticated usage with web search and image generation
meta_ai = Meta(fb_email="your_email@example.com", fb_password="your_password")
# Text prompt with web search
response = meta_ai.ask("What are the latest developments in quantum computing?")
print(response["message"])
print("Sources:", response["sources"])
# Image generation
response = meta_ai.ask("Create an image of a futuristic city")
for media in response.get("media", []):
print(media["url"])
```
</p>
</details>
<details>
<summary><b>Example: GROQ with Tool Calling</b></summary>
<p>
```python
from webscout import GROQ, DuckDuckGoSearch
import json
# Initialize GROQ client
client = GROQ(api_key="your_api_key")
# Define helper functions
def calculate(expression):
"""Evaluate a mathematical expression"""
try:
result = eval(expression)
return json.dumps({"result": result})
except Exception as e:
return json.dumps({"error": str(e)})
def search(query):
"""Perform a web search"""
try:
ddg = DuckDuckGoSearch()
results = ddg.text(query, max_results=3)
return json.dumps({"results": results})
except Exception as e:
return json.dumps({"error": str(e)})
# Register functions with GROQ
client.add_function("calculate", calculate)
client.add_function("search", search)
# Define tool specifications
tools = [
{
"type": "function",
"function": {
"name": "calculate",
"description": "Evaluate a mathematical expression",
"parameters": {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "The mathematical expression to evaluate"
}
},
"required": ["expression"]
}
}
},
{
"type": "function",
"function": {
"name": "search",
"description": "Perform a web search",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "The search query"
}
},
"required": ["query"]
}
}
}
]
# Use the tools
response = client.chat("What is 25 * 4 + 10?", tools=tools)
print(response)
response = client.chat("Find information about quantum computing", tools=tools)
print(response)
```
</p>
</details>
<details open>
<summary><b>GGUF Model Conversion</b></summary>
<p>
Webscout provides tools to convert and quantize Hugging Face models into the GGUF format for offline use.
> **Note (2026.01.01)**: GGUF conversion now uses lazy imports for `huggingface_hub`. The library can be imported without requiring `huggingface_hub`, and it's only loaded when GGUF features are actually used. Install it with `pip install huggingface_hub` if you need GGUF conversion.
```python
from webscout.Extra.gguf import ModelConverter
# Create a converter instance
converter = ModelConverter(
model_id="mistralai/Mistral-7B-Instruct-v0.2", # Hugging Face model ID
quantization_methods="q4_k_m" # Quantization method
)
# Run the conversion
converter.convert()
```
#### Available Quantization Methods
| Method | Description |
| -------- | ------------------------------------------------------------- |
| `fp16` | 16-bit floating point - maximum accuracy, largest size |
| `q2_k` | 2-bit quantization (smallest size, lowest accuracy) |
| `q3_k_l` | 3-bit quantization (large) - balanced for size/accuracy |
| `q3_k_m` | 3-bit quantization (medium) - good balance for most use cases |
| `q3_k_s` | 3-bit quantization (small) - optimized for speed |
| `q4_0` | 4-bit quantization (version 0) - standard 4-bit compression |
| `q4_1` | 4-bit quantization (version 1) - improved accuracy over q4_0 |
| `q4_k_m` | 4-bit quantization (medium) - balanced for most models |
| `q4_k_s` | 4-bit quantization (small) - optimized for speed |
| `q5_0` | 5-bit quantization (version 0) - high accuracy, larger size |
| `q5_1` | 5-bit quantization (version 1) - improved accuracy over q5_0 |
| `q5_k_m` | 5-bit quantization (medium) - best balance for quality/size |
| `q5_k_s` | 5-bit quantization (small) - optimized for speed |
| `q6_k` | 6-bit quantization - highest accuracy, largest size |
| `q8_0` | 8-bit quantization - maximum accuracy, largest size |
#### Command Line Usage
```bash
python -m webscout.Extra.gguf convert -m "mistralai/Mistral-7B-Instruct-v0.2" -q "q4_k_m"
```
</p>
</details>
<div align="center">
<p>
<a href="https://youtube.com/@OEvortex">▶️ Vortex's YouTube Channel</a> |
<a href="https://t.me/ANONYMOUS_56788">📢 Anonymous Coder's Telegram</a>
</p>
</div>
<hr/>
## 🤝 Contributing
Contributions are welcome! If you'd like to contribute to Webscout, please follow these steps:
1. Fork the repository
2. Create a new branch for your feature or bug fix
3. Make your changes and commit them with descriptive messages
4. Push your branch to your forked repository
5. Submit a pull request to the main repository
## 🙏 Acknowledgments
- All the amazing developers who have contributed to the project
- The open-source community for their support and inspiration
<hr/>
<div align="center">
<p>Made with ❤️ by the Webscout team</p>
</div>
| text/markdown | null | OEvortex <koulabhay26@gmail.com> | null | null | Apache-2.0 | search, ai, chatbot, llm, language-model, gpt, openai, gemini, claude, llama, search-engine, text-to-speech, tts, text-to-image, tti, weather, youtube, toolkit, utilities, web-search, duckduckgo, google, yep | [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Intended Audience :: End Users/Desktop",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: Apache Software License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Operating Sys... | [] | null | null | >=3.9 | [] | [] | [] | [
"setuptools",
"wheel",
"pip",
"curl_cffi",
"nest-asyncio",
"colorama",
"rich",
"PyYAML",
"html5lib",
"psutil",
"aiohttp",
"litprinter",
"lxml>=5.2.2",
"pydantic",
"ruff>=0.1.6; extra == \"dev\"",
"pytest>=7.4.2; extra == \"dev\"",
"fastapi; extra == \"api\"",
"uvicorn[standard]; ex... | [] | [] | [] | [
"Source, https://github.com/OEvortex/Webscout",
"Tracker, https://github.com/OEvortex/Webscout/issues",
"YouTube, https://youtube.com/@OEvortex"
] | twine/6.2.0 CPython/3.11.14 | 2026-02-18T10:02:52.462340 | webscout-2026.2.18.tar.gz | 665,959 | 0a/21/a01eeacc4ff5da02895a70c7a61d252fe607dbe5890b2ffde61ac774140e/webscout-2026.2.18.tar.gz | source | sdist | null | false | 3551f638ba450556d7c7d5b42c3abe88 | d3b6c5ecb5b123461028bbfa8a78e4bc2479c2cd1722839d2b1d4b3e1dfad815 | 0a21a01eeacc4ff5da02895a70c7a61d252fe607dbe5890b2ffde61ac774140e | null | [
"LICENSE.md"
] | 355 |
2.4 | checkov | 3.2.504 | Infrastructure as code static analysis | [](#)
[](https://prismacloud.io/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov)
[](https://github.com/bridgecrewio/checkov/actions?query=workflow%3Abuild)
[](https://github.com/bridgecrewio/checkov/actions?query=event%3Apush+branch%3Amaster+workflow%3Asecurity)
[](https://github.com/bridgecrewio/checkov/actions?query=workflow%3Acoverage)
[](https://www.checkov.io/1.Welcome/What%20is%20Checkov.html?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov)
[](https://pypi.org/project/checkov/)
[](#)
[](#)
[](https://pepy.tech/project/checkov)
[](https://hub.docker.com/r/bridgecrew/checkov)
[](https://codifiedsecurity.slack.com/)
**Checkov** is a static code analysis tool for infrastructure as code (IaC) and also a software composition analysis (SCA) tool for images and open source packages.
It scans cloud infrastructure provisioned using [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/OpenAPI.md), [ARM Templates](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Azure%20ARM%20templates.md), or [OpenTofu](https://opentofu.org/) and detects security and compliance misconfigurations using graph-based scanning.
It performs [Software Composition Analysis (SCA) scanning](docs/7.Scan%20Examples/Sca.md) which is a scan of open source packages and images for Common Vulnerabilities and Exposures (CVEs).
Checkov also powers [**Prisma Cloud Application Security**](https://www.prismacloud.io/prisma/cloud/cloud-code-security/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov), the developer-first platform that codifies and streamlines cloud security throughout the development lifecycle. Prisma Cloud identifies, fixes, and prevents misconfigurations in cloud resources and infrastructure-as-code files.
<a href="https://www.prismacloud.io/prisma/request-a-prisma-cloud-trial/?utm_campaign=checkov-github-repo&utm_source=github.com&utm_medium=get-started-button" title="Try_Prisma_Cloud">
<img src="https://dabuttonfactory.com/button.png?t=Try+Prisma+Cloud&f=Open+Sans-Bold&ts=26&tc=fff&hp=45&vp=20&c=round&bgt=unicolored&bgc=00c0e8" align="right" width="120">
</a>
<a href="https://docs.prismacloud.io/en/enterprise-edition/use-cases/secure-the-source/secure-the-source" title="Docs">
<img src="https://dabuttonfactory.com/button.png?t=Read+the+Docs&f=Open+Sans-Bold&ts=26&tc=fff&hp=45&vp=20&c=round&bgt=unicolored&bgc=00c0e8" align="right" width="120">
</a>
## **Table of contents**
- [Features](#features)
- [Screenshots](#screenshots)
- [Getting Started](#getting-started)
- [Disclaimer](#disclaimer)
- [Support](#support)
- [Migration - v2 to v3](https://github.com/bridgecrewio/checkov/blob/main/docs/1.Welcome/Migration.md)
## Features
* [Over 1000 built-in policies](https://github.com/bridgecrewio/checkov/blob/main/docs/5.Policy%20Index/all.md) cover security and compliance best practices for AWS, Azure and Google Cloud.
* Scans Terraform, Terraform Plan, Terraform JSON, CloudFormation, AWS SAM, Kubernetes, Helm, Kustomize, Dockerfile, Serverless framework, Ansible, Bicep, ARM, and OpenTofu template files.
* Scans Argo Workflows, Azure Pipelines, BitBucket Pipelines, Circle CI Pipelines, GitHub Actions and GitLab CI workflow files
* Supports Context-awareness policies based on in-memory graph-based scanning.
* Supports Python format for attribute policies and YAML format for both attribute and composite policies.
* Detects [AWS credentials](https://github.com/bridgecrewio/checkov/blob/main/docs/2.Basics/Scanning%20Credentials%20and%20Secrets.md) in EC2 Userdata, Lambda environment variables and Terraform providers.
* [Identifies secrets](https://www.prismacloud.io/prisma/cloud/secrets-security) using regular expressions, keywords, and entropy based detection.
* Evaluates [Terraform Provider](https://registry.terraform.io/browse/providers) settings to regulate the creation, management, and updates of IaaS, PaaS or SaaS managed through Terraform.
* Policies support evaluation of [variables](https://github.com/bridgecrewio/checkov/blob/main/docs/2.Basics/Handling%20Variables.md) to their optional default value.
* Supports in-line [suppression](https://github.com/bridgecrewio/checkov/blob/main/docs/2.Basics/Suppressing%20and%20Skipping%20Policies.md) of accepted risks or false-positives to reduce recurring scan failures. Also supports global skip from using CLI.
* [Output](https://github.com/bridgecrewio/checkov/blob/main/docs/2.Basics/Reviewing%20Scan%20Results.md) currently available as CLI, [CycloneDX](https://cyclonedx.org), JSON, JUnit XML, CSV, SARIF and github markdown and link to remediation [guides](https://docs.prismacloud.io/en/enterprise-edition/policy-reference/).
## Screenshots
Scan results in CLI
Scheduled scan result in Jenkins
## Getting started
### Requirements
* Python >= 3.9, <=3.12
* Terraform >= 0.12
### Installation
To install pip follow the official [docs](https://pip.pypa.io/en/stable/cli/pip_install/)
```sh
pip3 install checkov
```
Certain environments (e.g., Debian 12) may require you to install Checkov in a virtual environment
```sh
# Create and activate a virtual environment
python3 -m venv /path/to/venv/checkov
cd /path/to/venv/checkov
source ./bin/activate
# Install Checkov with pip
pip install checkov
# Optional: Create a symlink for easy access
sudo ln -s /path/to/venv/checkov/bin/checkov /usr/local/bin/checkov
```
or with [Homebrew](https://formulae.brew.sh/formula/checkov) (macOS or Linux)
```sh
brew install checkov
```
### Enabling bash autocomplete
```sh
source <(register-python-argcomplete checkov)
```
### Upgrade
if you installed checkov with pip3
```sh
pip3 install -U checkov
```
or with Homebrew
```sh
brew upgrade checkov
```
### Configure an input folder or file
```sh
checkov --directory /user/path/to/iac/code
```
Or a specific file or files
```sh
checkov --file /user/tf/example.tf
```
Or
```sh
checkov -f /user/cloudformation/example1.yml -f /user/cloudformation/example2.yml
```
Or a terraform plan file in json format
```sh
terraform init
terraform plan -out tf.plan
terraform show -json tf.plan > tf.json
checkov -f tf.json
```
Note: `terraform show` output file `tf.json` will be a single line.
For that reason all findings will be reported line number 0 by Checkov
```sh
check: CKV_AWS_21: "Ensure all data stored in the S3 bucket have versioning enabled"
FAILED for resource: aws_s3_bucket.customer
File: /tf/tf.json:0-0
Guide: https://docs.prismacloud.io/en/enterprise-edition/policy-reference/aws-policies/s3-policies/s3-16-enable-versioning
```
If you have installed `jq` you can convert json file into multiple lines with the following command:
```sh
terraform show -json tf.plan | jq '.' > tf.json
```
Scan result would be much user friendly.
```sh
checkov -f tf.json
Check: CKV_AWS_21: "Ensure all data stored in the S3 bucket have versioning enabled"
FAILED for resource: aws_s3_bucket.customer
File: /tf/tf1.json:224-268
Guide: https://docs.prismacloud.io/en/enterprise-edition/policy-reference/aws-policies/s3-policies/s3-16-enable-versioning
225 | "values": {
226 | "acceleration_status": "",
227 | "acl": "private",
228 | "arn": "arn:aws:s3:::mybucket",
```
Alternatively, specify the repo root of the hcl files used to generate the plan file, using the `--repo-root-for-plan-enrichment` flag, to enrich the output with the appropriate file path, line numbers, and codeblock of the resource(s). An added benefit is that check suppressions will be handled accordingly.
```sh
checkov -f tf.json --repo-root-for-plan-enrichment /user/path/to/iac/code
```
### Scan result sample (CLI)
```sh
Passed Checks: 1, Failed Checks: 1, Suppressed Checks: 0
Check: "Ensure all data stored in the S3 bucket is securely encrypted at rest"
/main.tf:
Passed for resource: aws_s3_bucket.template_bucket
Check: "Ensure all data stored in the S3 bucket is securely encrypted at rest"
/../regionStack/main.tf:
Failed for resource: aws_s3_bucket.sls_deployment_bucket_name
```
Start using Checkov by reading the [Getting Started](https://github.com/bridgecrewio/checkov/blob/main/docs/1.Welcome/Quick%20Start.md) page.
### Using Docker
```sh
docker pull bridgecrew/checkov
docker run --tty --rm --volume /user/tf:/tf --workdir /tf bridgecrew/checkov --directory /tf
```
Note: if you are using Python 3.6(Default version in Ubuntu 18.04) checkov will not work, and it will fail with `ModuleNotFoundError: No module named 'dataclasses'` error message. In this case, you can use the docker version instead.
Note that there are certain cases where redirecting `docker run --tty` output to a file - for example, if you want to save the Checkov JUnit output to a file - will cause extra control characters to be printed. This can break file parsing. If you encounter this, remove the `--tty` flag.
The `--workdir /tf` flag is optional to change the working directory to the mounted volume. If you are using the SARIF output `-o sarif` this will output the results.sarif file to the mounted volume (`/user/tf` in the example above). If you do not include that flag, the working directory will be "/".
### Running or skipping checks
By using command line flags, you can specify to run only named checks (allow list) or run all checks except
those listed (deny list). If you are using the platform integration via API key, you can also specify a severity threshold to skip and / or include.
Moreover, as json files can't contain comments, one can pass regex pattern to skip json file secret scan.
See the docs for more detailed information about how these flags work together.
## Examples
Allow only the two specified checks to run:
```sh
checkov --directory . --check CKV_AWS_20,CKV_AWS_57
```
Run all checks except the one specified:
```sh
checkov -d . --skip-check CKV_AWS_20
```
Run all checks except checks with specified patterns:
```sh
checkov -d . --skip-check CKV_AWS*
```
Run all checks that are MEDIUM severity or higher (requires API key):
```sh
checkov -d . --check MEDIUM --bc-api-key ...
```
Run all checks that are MEDIUM severity or higher, as well as check CKV_123 (assume this is a LOW severity check):
```sh
checkov -d . --check MEDIUM,CKV_123 --bc-api-key ...
```
Skip all checks that are MEDIUM severity or lower:
```sh
checkov -d . --skip-check MEDIUM --bc-api-key ...
```
Skip all checks that are MEDIUM severity or lower, as well as check CKV_789 (assume this is a high severity check):
```sh
checkov -d . --skip-check MEDIUM,CKV_789 --bc-api-key ...
```
Run all checks that are MEDIUM severity or higher, but skip check CKV_123 (assume this is a medium or higher severity check):
```sh
checkov -d . --check MEDIUM --skip-check CKV_123 --bc-api-key ...
```
Run check CKV_789, but skip it if it is a medium severity (the --check logic is always applied before --skip-check)
```sh
checkov -d . --skip-check MEDIUM --check CKV_789 --bc-api-key ...
```
For Kubernetes workloads, you can also use allow/deny namespaces. For example, do not report any results for the
kube-system namespace:
```sh
checkov -d . --skip-check kube-system
```
Run a scan of a container image. First pull or build the image then refer to it by the hash, ID, or name:tag:
```sh
checkov --framework sca_image --docker-image sha256:1234example --dockerfile-path /Users/path/to/Dockerfile --repo-id ... --bc-api-key ...
checkov --docker-image <image-name>:tag --dockerfile-path /User/path/to/Dockerfile --repo-id ... --bc-api-key ...
```
You can use --image flag also to scan container image instead of --docker-image for shortener:
```sh
checkov --image <image-name>:tag --dockerfile-path /User/path/to/Dockerfile --repo-id ... --bc-api-key ...
```
Run an SCA scan of packages in a repo:
```sh
checkov -d . --framework sca_package --bc-api-key ... --repo-id <repo_id(arbitrary)>
```
Run a scan of a directory with environment variables removing buffering, adding debug level logs:
```sh
PYTHONUNBUFFERED=1 LOG_LEVEL=DEBUG checkov -d .
```
OR enable the environment variables for multiple runs
```sh
export PYTHONUNBUFFERED=1 LOG_LEVEL=DEBUG
checkov -d .
```
Run secrets scanning on all files in MyDirectory. Skip CKV_SECRET_6 check on json files that their suffix is DontScan
```sh
checkov -d /MyDirectory --framework secrets --repo-id ... --bc-api-key ... --skip-check CKV_SECRET_6:.*DontScan.json$
```
Run secrets scanning on all files in MyDirectory. Skip CKV_SECRET_6 check on json files that contains "skip_test" in path
```sh
checkov -d /MyDirectory --framework secrets --repo-id ... --bc-api-key ... --skip-check CKV_SECRET_6:.*skip_test.*json$
```
One can mask values from scanning results by supplying a configuration file (using --config-file flag) with mask entry.
The masking can apply on resource & value (or multiple values, separated with a comma).
Examples:
```sh
mask:
- aws_instance:user_data
- azurerm_key_vault_secret:admin_password,user_passwords
```
In the example above, the following values will be masked:
- user_data for aws_instance resource
- both admin_password &user_passwords for azurerm_key_vault_secret
### Suppressing/Ignoring a check
Like any static-analysis tool it is limited by its analysis scope.
For example, if a resource is managed manually, or using subsequent configuration management tooling,
suppression can be inserted as a simple code annotation.
#### Suppression comment format
To skip a check on a given Terraform definition block or CloudFormation resource, apply the following comment pattern inside it's scope:
`checkov:skip=<check_id>:<suppression_comment>`
* `<check_id>` is one of the [available check scanners](docs/5.Policy Index/all.md)
* `<suppression_comment>` is an optional suppression reason to be included in the output
#### Example
The following comment skips the `CKV_AWS_20` check on the resource identified by `foo-bucket`, where the scan checks if an AWS S3 bucket is private.
In the example, the bucket is configured with public read access; Adding the suppress comment would skip the appropriate check instead of the check to fail.
```hcl-terraform
resource "aws_s3_bucket" "foo-bucket" {
region = var.region
#checkov:skip=CKV_AWS_20:The bucket is a public static content host
bucket = local.bucket_name
force_destroy = true
acl = "public-read"
}
```
The output would now contain a ``SKIPPED`` check result entry:
```bash
...
...
Check: "S3 Bucket has an ACL defined which allows public access."
SKIPPED for resource: aws_s3_bucket.foo-bucket
Suppress comment: The bucket is a public static content host
File: /example_skip_acl.tf:1-25
...
```
To skip multiple checks, add each as a new line.
```
#checkov:skip=CKV2_AWS_6
#checkov:skip=CKV_AWS_20:The bucket is a public static content host
```
To suppress checks in Kubernetes manifests, annotations are used with the following format:
`checkov.io/skip#: <check_id>=<suppression_comment>`
For example:
```bash
apiVersion: v1
kind: Pod
metadata:
name: mypod
annotations:
checkov.io/skip1: CKV_K8S_20=I don't care about Privilege Escalation :-O
checkov.io/skip2: CKV_K8S_14
checkov.io/skip3: CKV_K8S_11=I have not set CPU limits as I want BestEffort QoS
spec:
containers:
...
```
#### Logging
For detailed logging to stdout set up the environment variable `LOG_LEVEL` to `DEBUG`.
Default is `LOG_LEVEL=WARNING`.
#### Skipping directories
To skip files or directories, use the argument `--skip-path`, which can be specified multiple times. This argument accepts regular expressions for paths relative to the current working directory. You can use it to skip entire directories and / or specific files.
By default, all directories named `node_modules`, `.terraform`, and `.serverless` will be skipped, in addition to any files or directories beginning with `.`.
To cancel skipping directories beginning with `.` override `CKV_IGNORE_HIDDEN_DIRECTORIES` environment variable `export CKV_IGNORE_HIDDEN_DIRECTORIES=false`
You can override the default set of directories to skip by setting the environment variable `CKV_IGNORED_DIRECTORIES`.
Note that if you want to preserve this list and add to it, you must include these values. For example, `CKV_IGNORED_DIRECTORIES=mynewdir` will skip only that directory, but not the others mentioned above. This variable is legacy functionality; we recommend using the `--skip-file` flag.
#### Console Output
The console output is in colour by default, to switch to a monochrome output, set the environment variable:
`ANSI_COLORS_DISABLED`
#### VS Code Extension
If you want to use Checkov within VS Code, give the [Prisma Cloud extension](https://marketplace.visualstudio.com/items?itemName=PrismaCloud.prisma-cloud) a try.
### Configuration using a config file
Checkov can be configured using a YAML configuration file. By default, checkov looks for a `.checkov.yaml` or `.checkov.yml` file in the following places in order of precedence:
* Directory against which checkov is run. (`--directory`)
* Current working directory where checkov is called.
* User's home directory.
**Attention**: it is a best practice for checkov configuration file to be loaded from a trusted source composed by a verified identity, so that scanned files, check ids and loaded custom checks are as desired.
Users can also pass in the path to a config file via the command line. In this case, the other config files will be ignored. For example:
```sh
checkov --config-file path/to/config.yaml
```
Users can also create a config file using the `--create-config` command, which takes the current command line args and writes them out to a given path. For example:
```sh
checkov --compact --directory test-dir --docker-image sample-image --dockerfile-path Dockerfile --download-external-modules True --external-checks-dir sample-dir --quiet --repo-id prisma-cloud/sample-repo --skip-check CKV_DOCKER_3,CKV_DOCKER_2 --skip-framework dockerfile secrets --soft-fail --branch develop --check CKV_DOCKER_1 --create-config /Users/sample/config.yml
```
Will create a `config.yaml` file which looks like this:
```yaml
branch: develop
check:
- CKV_DOCKER_1
compact: true
directory:
- test-dir
docker-image: sample-image
dockerfile-path: Dockerfile
download-external-modules: true
evaluate-variables: true
external-checks-dir:
- sample-dir
external-modules-download-path: .external_modules
framework:
- all
output: cli
quiet: true
repo-id: prisma-cloud/sample-repo
skip-check:
- CKV_DOCKER_3
- CKV_DOCKER_2
skip-framework:
- dockerfile
- secrets
soft-fail: true
```
Users can also use the `--show-config` flag to view all the args and settings and where they came from i.e. commandline, config file, environment variable or default. For example:
```sh
checkov --show-config
```
Will display:
```sh
Command Line Args: --show-config
Environment Variables:
BC_API_KEY: your-api-key
Config File (/Users/sample/.checkov.yml):
soft-fail: False
branch: master
skip-check: ['CKV_DOCKER_3', 'CKV_DOCKER_2']
Defaults:
--output: cli
--framework: ['all']
--download-external-modules:False
--external-modules-download-path:.external_modules
--evaluate-variables:True
```
## Contributing
Contribution is welcomed!
Start by reviewing the [contribution guidelines](https://github.com/bridgecrewio/checkov/blob/main/CONTRIBUTING.md). After that, take a look at a [good first issue](https://github.com/bridgecrewio/checkov/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
You can even start this with one-click dev in your browser through Gitpod at the following link:
[](https://gitpod.io/#https://github.com/bridgecrewio/checkov)
Looking to contribute new checks? Learn how to write a new check (AKA policy) [here](https://github.com/bridgecrewio/checkov/blob/main/docs/6.Contribution/Contribution%20Overview.md).
## Disclaimer
`checkov` does not save, publish or share with anyone any identifiable customer information.
No identifiable customer information is used to query Prisma Cloud's publicly accessible guides.
`checkov` uses Prisma Cloud's API to enrich the results with links to remediation guides.
To skip this API call use the flag `--skip-download`.
## Support
[Prisma Cloud](https://www.prismacloud.io/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov) builds and maintains Checkov to make policy-as-code simple and accessible.
Start with our [Documentation](https://www.checkov.io/1.Welcome/Quick%20Start.html) for quick tutorials and examples.
## Python Version Support
We follow the official support cycle of Python, and we use automated tests for supported versions of Python.
This means we currently support Python 3.9 - 3.13, inclusive.
Note that Python 3.8 reached EOL on October 2024 and Python 3.9 will reach EOL in October 2025.
If you run into any issues with any non-EOL Python version, please open an Issue.
| text/markdown | bridgecrew | meet@bridgecrew.io | null | null | Apache License 2.0 | null | [
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programmin... | [] | https://github.com/bridgecrewio/checkov | null | >=3.9 | [] | [] | [] | [
"bc-python-hcl2==0.4.3",
"bc-detect-secrets==1.5.45",
"bc-jsonpath-ng==1.6.1",
"pycep-parser==0.6.1",
"tabulate<0.10.0,>=0.9.0",
"colorama<0.5.0,>=0.4.3",
"termcolor<2.4.0,>=1.1.0",
"junit-xml<2.0,>=1.9",
"dpath==2.1.3",
"pyyaml<7.0.0,>=6.0.0",
"boto3==1.35.49",
"gitpython<4.0.0,>=3.1.30",
"... | [] | [] | [] | [] | twine/6.1.0 CPython/3.12.9 | 2026-02-18T10:02:34.225042 | checkov-3.2.504.tar.gz | 991,416 | c6/06/889c4601e9b2123e8b138b3acb30764d0147af9bd4f12751f7ace78f3964/checkov-3.2.504.tar.gz | source | sdist | null | false | d3b9d64d5a5cecd48511a5efe6daf19b | 785458a20c123022977f98fe94c301cb08fc0ce8dc6c56575c3ac65338586dba | c606889c4601e9b2123e8b138b3acb30764d0147af9bd4f12751f7ace78f3964 | null | [
"LICENSE"
] | 189,812 |
2.4 | clawprompt | 1.0.0 | Smart teleprompter with mobile remote control for video recording | # ClawPrompt 🦞📝
Smart teleprompter with mobile remote control for video recording.
## Features
- 🖥️ **Fullscreen teleprompter** — black background, white text, top-center aligned
- 📱 **Mobile remote control** — scan QR code, phone becomes a page-turner
- 🔄 **Dual-screen sync** — computer and phone show the same text in real-time
- 📝 **Upload from either device** — paste text on computer or phone
- 🎬 **ClawCut integration** — import AI-generated 9-scene scripts directly
- ⏱️ **Countdown start** — 3-second countdown before prompting begins
- 🔤 **Adjustable font size** — +/- keys to resize on the fly
## Quick Start
```bash
npm install
node server.js
```
Open `http://localhost:7870` on your computer.
Scan the QR code with your phone (same WiFi).
## Usage
1. **Computer**: Paste your script → click "开始提词" → fullscreen mode
2. **Phone**: Scan QR → tap "下一句" to advance, "上一句" to go back
3. **Recording**: Speaker looks at camera, reads text with peripheral vision. Another person controls the phone.
### Keyboard Shortcuts (Computer)
| Key | Action |
|-----|--------|
| Space / ↓ | Next sentence |
| ↑ | Previous sentence |
| + / - | Increase / decrease font size |
| ESC | Exit fullscreen |
## Use Case
Perfect for video recording where the speaker needs to focus on camera eye contact, gestures, and expression — while a director/assistant controls the script pacing from their phone.
## Configuration
| Env Var | Default | Description |
|---------|---------|-------------|
| `PORT` | `7870` | Server port |
## Requirements
- Node.js 18+
- `ws` npm package (auto-installed)
- `qrcode` npm package (auto-installed)
- Computer and phone on the same WiFi
## License
MIT
| text/markdown | null | jiafar <renjiawei0211@gmail.com> | null | null | MIT | teleprompter, prompter, video, recording, remote-control | [
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Topic :: Multimedia :: Video"
] | [] | null | null | >=3.8 | [] | [] | [] | [] | [] | [] | [] | [
"Homepage, https://github.com/jiafar/clawprompt"
] | twine/6.2.0 CPython/3.11.9 | 2026-02-18T10:01:46.992341 | clawprompt-1.0.0.tar.gz | 11,495 | db/6e/bb1cd207c50294c13a14688f9658a5b4632bd4dfaa64ef0486c80cfddf16/clawprompt-1.0.0.tar.gz | source | sdist | null | false | f1c8e5de7bddc1c253876d5640819c34 | 03d9130b22589f9e7575b49d0d5dde2d1596892421c82d14156c9e57e2e17acf | db6ebb1cd207c50294c13a14688f9658a5b4632bd4dfaa64ef0486c80cfddf16 | null | [
"LICENSE"
] | 265 |
2.4 | synalinks-memory | 0.0.2 | Python SDK for the Synalinks Memory API | # Synalinks Memory Python SDK
**Synalinks Memory** is the knowledge and context layer for AI agents. It lets your agents always have the right context at the right time. Unlike retrieval systems that compound LLM errors at every step, Synalinks uses **logical rules** to derive knowledge from your raw data. Every claim can be traced back to evidence, from raw data to insight, no more lies or hallucinations.
This SDK provides a Python client to interact with the Synalinks Memory API, so your agents can store, query, and reason over their knowledge base programmatically.
## Installation
```bash
pip install synalinks-memory
```
Or with [uv](https://docs.astral.sh/uv/):
```bash
uv add synalinks-memory
```
## Quick Start
Set your API key as an environment variable:
```bash
export SYNALINKS_API_KEY="synalinks_..."
```
Then query your data:
```python
from synalinks_memory import SynalinksMemory
with SynalinksMemory() as client:
# List all available tables, concepts, and rules
predicates = client.list()
for table in predicates.tables:
print(f"{table.name}: {table.description}")
# Fetch rows from a table
result = client.execute("Users", limit=10)
for row in result.rows:
print(row)
# Search with keywords (fuzzy matching)
result = client.search("Users", "alice")
for row in result.rows:
print(row)
# Upload a CSV or Parquet file
upload = client.upload("data/sales.csv", name="Sales", description="Monthly sales data")
print(f"Uploaded {upload.predicate} ({upload.row_count} rows)")
# Export data as a file (CSV, Parquet, or JSON)
client.execute("Users", format="csv", output="users.csv")
client.execute("Users", format="parquet", output="users.parquet")
# Ask the agent a question
answer = client.ask("What were the top 5 products by revenue last month?")
print(answer)
```
You can also pass the key directly:
```python
client = SynalinksMemory(api_key="synalinks_...")
```
### Error Handling
```python
from synalinks_memory import (
SynalinksMemory,
AuthenticationError,
NotFoundError,
RateLimitError,
)
with SynalinksMemory() as client:
try:
result = client.execute("MyTable")
except AuthenticationError:
print("Invalid API key")
except NotFoundError as e:
print(f"Not found: {e.message}")
except RateLimitError as e:
print(f"Rate limited, retry after {e.retry_after}s")
```
## API Reference
### `SynalinksMemory(api_key=None, base_url=None, timeout=30.0)`
| Parameter | Description |
|-----------|-------------|
| `api_key` | Your API key. If omitted, reads from `SYNALINKS_API_KEY` env var. |
| `base_url` | Override the API endpoint (defaults to `https://app.synalinks.com/api`). |
| `timeout` | Request timeout in seconds. |
### Methods
| Method | Description |
|--------|-------------|
| `list()` | List all tables, concepts, and rules |
| `execute(predicate, *, limit=100, offset=0, format=None, output=None)` | Fetch rows (or export as json/csv/parquet file when *format* is set) |
| `search(predicate, keywords, *, limit=100, offset=0)` | Search rows by keywords (fuzzy matching) |
| `upload(file_path, *, name=None, description=None, overwrite=False)` | Upload a CSV or Parquet file as a new table |
| `ask(question)` | Ask the agent a question, returns the answer string |
| `close()` | Close the HTTP client (not needed with `with` statement) |
## License
Apache 2.0
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"httpx>=0.27",
"pydantic>=2.0"
] | [] | [] | [] | [] | uv/0.6.7 | 2026-02-18T10:01:36.764426 | synalinks_memory-0.0.2.tar.gz | 32,625 | 65/c7/a9c792b73306b14b5c52a82a189c80543816477536daebefbef10b38be2c/synalinks_memory-0.0.2.tar.gz | source | sdist | null | false | 0154c8f68149471baf2ec63e4471ab3c | eec7c1225e0653988d2decf85ed18773a788ca3dd2f333ac74bd85620e74a123 | 65c7a9c792b73306b14b5c52a82a189c80543816477536daebefbef10b38be2c | Apache-2.0 | [
"LICENSE"
] | 255 |
2.4 | dataforseo-client | 2.0.20 | DataForSEO API documentation | ## OVERVIEW
This is a Python client providing you, as a developer, with a tool for obtaining the necessary data from DataForSEO APIs. You don't have to figure out how to make a request and process a response - all that is readily available in this client.
[](https://github.com/dataforseo/PythonClient/issues)
[](https://github.com/dataforseo/PythonClient)
DataForSEO API uses REST technology for interchanging data between your application and our service. The data exchange is made through the widely used HTTP protocol, which allows using our API with almost any programming language.
Client contains 12 sections (aka APIs):
- AI Optimization API ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/AiOptimizationApi.md) | [api docs](https://docs.dataforseo.com/v3/ai_optimization/overview/))
- SERP ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/SerpApi.md) | [api docs](https://docs.dataforseo.com/v3/serp/overview/?bash))
- Keywords Data ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/KeywordsDataApi.md) | [api docs](https://docs.dataforseo.com/v3/keywords_data/overview/?bash))
- Domain Analytics ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/DomainAnalyticsApi.md) | [api docs](https://docs.dataforseo.com/v3/domain_analytics/overview/?bash))
- DataForSEO Labs ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/DataforseoLabsApi.md) | [api docs](https://docs.dataforseo.com/v3/dataforseo_labs/overview/?bash))
- Backlinks ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/BacklinksApi.md) | [api docs](https://docs.dataforseo.com/v3/backlinks/overview/?bash))
- OnPage ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/OnPageApi.md) | [api docs](https://docs.dataforseo.com/v3/on_page/overview/?bash))
- Content Analysis ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/ContentAnalysisApi.md) | [api docs](https://docs.dataforseo.com/v3/content_analysis/overview/?bash))
- Merchant ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/MerchantApi.md) | [api docs](https://docs.dataforseo.com/v3/merchant/overview/?bash))
- AppData ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/AppDataApi.md) | [api docs](https://docs.dataforseo.com/v3/app_data/overview/?bash))
- Business Data ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/BusinessDataApi.md) | [api docs](https://docs.dataforseo.com/v3/business_data/overview/?bash))
- Appendix ([source docs](https://github.com/dataforseo/PythonClient/blob/master/docs/AppendixApi.md) | [api docs](https://docs.dataforseo.com/v3/appendix/user_data/?bash))
API Contains 2 types of requests:
1) Live (Simple HTTP request/response message)
2) Task-based (Requires sending a 'Task' entity to execute, waiting until the 'Task' status is ready, and getting the 'Task' result in a special endpoint. Usually, it is represented by 3 types of endpoints: 'TaskPost', 'TaskReady', and 'TaskGet')
For more details - please follow [here](https://docs.dataforseo.com/v3/?bash)
## YAML Spec
Our API description is based on the OpenAPI [syntax](https://spec.openapis.org/oas/v3.1.0) in YAML format. The YAML file attached to the project [here](https://github.com/dataforseo/OpenApiDocumentation)
## Documentation
The documentation for code objects, formatted in Markdown (.md) is available [here](https://github.com/dataforseo/PythonClient/blob/master/docs/). Official documentation for DataForSEO API is available [here](https://docs.dataforseo.com/v3/?bash).
## Code generation
Code generated using the [openapi generator cli](https://openapi-generator.tech/docs/installation/)
## Install package from nuget.org
```bash
pip install dataforseo-client
```
## Examples of usage
Example of live request
```python
from dataforseo_client import configuration as dfs_config, api_client as dfs_api_provider
from dataforseo_client.api.serp_api import SerpApi
from dataforseo_client.rest import ApiException
from dataforseo_client.models.serp_google_organic_live_advanced_request_info import SerpGoogleOrganicLiveAdvancedRequestInfo
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
configuration = dfs_config.Configuration(username='USERNAME',password='PASSWORD')
with dfs_api_provider.ApiClient(configuration) as api_client:
# Create an instance of the API class
serp_api = SerpApi(api_client)
try:
api_response = serp_api.google_organic_live_advanced([SerpGoogleOrganicLiveAdvancedRequestInfo(
language_name="English",
location_name="United States",
keyword="albert einstein"
)])
pprint(api_response)
except ApiException as e:
print("Exception: %s\n" % e)
```
Example of Task-Based request
```python
from dataforseo_client import configuration as dfs_config, api_client as dfs_api_provider
from dataforseo_client.api.serp_api import SerpApi
from dataforseo_client.rest import ApiException
from dataforseo_client.models.serp_task_request_info import SerpTaskRequestInfo
from pprint import pprint
import asyncio
import time
# Configure HTTP basic authorization: basicAuth
configuration = dfs_config.Configuration(username='USERNAME',password='PASSWORD')
def GoogleOrganicTaskReady(id):
result = serp_api.google_organic_tasks_ready()
return any(any(xx.id == id for xx in x.result) for x in result.tasks)
with dfs_api_provider.ApiClient(configuration) as api_client:
# Create an instance of the API class
serp_api = SerpApi(api_client)
try:
task_post = serp_api.google_organic_task_post([SerpTaskRequestInfo(
language_name="English",
location_name="United States",
keyword="albert einstein"
)])
task_id = task_post.tasks[0].id
start_time = time.time()
while GoogleOrganicTaskReady(task_id) is not True and (time.time() - start_time) < 60:
asyncio.sleep(1)
api_response = serp_api.google_organic_task_get_advanced(id=task_id)
pprint(api_response)
except ApiException as e:
print("Exception: %s\n" % e)
```
| text/markdown | DataForSeo | info@dataforseo.com | null | null | null | OpenAPI, DataForSEO, DataForSEO API documentation | [] | [] | https://github.com/dataforseo/PythonClient | null | null | [] | [] | [] | [
"urllib3>=1.25.3",
"python-dateutil",
"pydantic>=2",
"typing-extensions>=4.7.1"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.14.0 | 2026-02-18T10:01:28.596809 | dataforseo_client-2.0.20.tar.gz | 1,084,051 | f7/ce/2b9e645d870b334869648de607244598402bab4a112da6b57f79f8a13cab/dataforseo_client-2.0.20.tar.gz | source | sdist | null | false | 38a44658801f9563f4925493f7a3aef8 | e5949b5f8daf619dc846854ae63675a277af55c78c5d05db292d13218a22adb4 | f7ce2b9e645d870b334869648de607244598402bab4a112da6b57f79f8a13cab | null | [] | 584 |
2.4 | multilat-solver | 0.0.0 | Universal MultiLateration Localization System with flexible input/output adapters | # MultiLat Localizer
Universal multilateration localization with pluggable input/output adapters for distance measurements and position output.
**Version:** 1.0.0
## Features
- **Inputs:** Serial (UWB/RTK-DW1000), MQTT, UDP, File; custom adapters via `with_input()`
- **Outputs:** MAVLink, MAVROS (ROS2), UDP, File, Console; multiple outputs at once
- **Calibration:** None, Linear, Quadratic, Cubic
- **GPS:** ENU → GPS via pymap3d; frequency throttling; message type (GPS / Position / Both)
- **Config:** Python API only (no config files)
## Installation
```bash
pip install multilat_solver
```
Optional: `pip install multilat_solver[mqtt]` (MQTT), `multilat_solver[ros2]` (ROS2), `.[dev]` (development).
## Quick Start
```python
from multilat_solver import ConfigBuilder, MultiLatLocalizerApp, CalibrationType
from multilat_solver.common_types import MessageType
from multilat_solver.output_adapters import ConsoleOutputAdapter
import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
config = (ConfigBuilder()
.with_localization(
anchor_positions={1: (0, 0, 0), 2: (3, 0, 0), 3: (0, 3, 0)},
calibration_type=CalibrationType.LINEAR,
calibration_params=[1.0, 0.0],
)
.with_serial_input(port="/dev/ttyUSB0", baud=460800)
.with_output("console", ConsoleOutputAdapter(format="human", message_type=MessageType.BOTH, frequency=10))
.build())
app = MultiLatLocalizerApp(config)
app.run()
```
## Documentation
- [Configuration](docs/configuration.md) · [Input adapters](docs/input-adapters.md) · [Output adapters](docs/output-adapters.md)
- [Calibration](docs/calibration.md) · [Examples](docs/examples.md) · [Custom adapters](docs/extension.md)
## Adapters
| Input | Description |
|---------|--------------------------------|
| Serial | Binary protocol (UWB/RTK-DW1000) |
| MQTT | JSON over MQTT `[mqtt]` |
| UDP | JSON over UDP |
| File | JSON file polling |
| Output | Description |
|---------|--------------------------------|
| MAVLink | ArduPilot/PX4 |
| MAVROS | ROS2 topics `[ros2]` |
| UDP | JSON over UDP |
| File | JSONL file |
| Console | Human or JSON |
## Examples
- `examples/basic_usage.py` — Serial in, console/file/MAVLink out
- `examples/multi_output.py` — Multiple outputs
- `examples/mavlink_input_with_sim.py` — MAVLink distances in + simulator
- `examples/uavcan_input_mavlink_output.py` — Custom UAVCAN input → MAVLink out
## Development
```bash
git clone https://github.com/Innopolis-UAV-Team/multilat_solver
cd multilat_solver
pip install -e ".[dev]"
pytest
```
Layout: `src/multilat_solver/` — `core.py`, `config.py`, `app.py`, `input_adapters.py`, `output_adapters.py`, `common_types.py`.
| text/markdown | null | Anastasiia Stepanova <asiiapine@gmail.com> | null | null | GNU General Public License v3.0 | localization, trilateration, multilateration, mavlink, ros2, anchors | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Topic :: Scientific/Engineering"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"numpy",
"pyserial",
"pymap3d",
"pymavlink",
"scipy",
"localization",
"toml",
"paho-mqtt; extra == \"mqtt\"",
"rclpy; extra == \"ros2\"",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-mock>=3.10.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/Innopolis-UAV-Team/multilat_solver",
"Documentation, https://github.com/Innopolis-UAV-Team/multilat_solver#readme",
"Repository, https://github.com/Innopolis-UAV-Team/multilat_solver",
"Issues, https://github.com/Innopolis-UAV-Team/multilat_solver/issues"
] | twine/6.2.0 CPython/3.10.19 | 2026-02-18T10:00:37.511782 | multilat_solver-0.0.0.tar.gz | 34,577 | b9/4e/6bd5f24fa8e844b8f1045c103f9efe0874ef31d0957afe3a4b95ec716df8/multilat_solver-0.0.0.tar.gz | source | sdist | null | false | f4c3d107ba8c3d57f9c1976b9162ab1e | f8df5c192b2153e5533c7bc50e669f7ff98bde7fe51b0ef16d499a1e10d20a3e | b94e6bd5f24fa8e844b8f1045c103f9efe0874ef31d0957afe3a4b95ec716df8 | null | [
"LICENSE"
] | 252 |
2.4 | zou | 1.0.14 | API to store and manage the data of your animation production | .. figure:: https://zou.cg-wire.com/kitsu.png
:alt: Kitsu Logo
Zou, the Kitsu API is the memory of your animation production
-------------------------------------------------------------
The Kitsu API allows to store and manage the data of your animation/VFX
production. Through it, you can link all the tools of your pipeline and make
sure they are all synchronized.
A dedicated Python client, `Gazu <https://gazu.cg-wire.com>`_, allows users to
integrate Zou into the tools.
|CI badge| |Downloads badge| |Discord badge|
Features
~~~~~~~~
Zou can:
- Store production data, such as projects, shots, assets, tasks, and file metadata.
- Track the progress of your artists
- Store preview files and version them
- Provide folder and file paths for any task
- Import and Export data to CSV files
- Publish an event stream of changes
Installation and Documentation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Installation of Zou requires the setup of third-party tools such as a database
instance, so it is recommended to follow the documentation:
`https://zou.cg-wire.com/ <https://zou.cg-wire.com>`__
Specification:
- `https://api-docs.kitsu.cloud/ <https://api-docs.kitsu.cloud>`__
Contributing
------------
Contributions are welcomed so long as the `C4
contract <https://rfc.zeromq.org/spec:42/C4>`__ is respected.
Zou is based on Python and the `Flask <http://flask.pocoo.org/>`__
framework.
You can use the pre-commit hook for Black (a Python code formatter) before
committing:
.. code:: bash
pip install pre-commit
pre-commit install
Instructions for setting up a development environment are available in
`the documentation <https://zou.cg-wire.com/development/>`__
Contributors
------------
* @aboellinger (Xilam/Spa)
* @BigRoy (Colorbleed)
* @EvanBldy (CGWire) - *maintainer*
* @ex5 (Blender Studio)
* @flablog (Les Fées Spéciales)
* @frankrousseau (CGWire) - *maintainer*
* @kaamaurice (Tchak)
* @g-Lul (TNZPV)
* @pilou (Freelancer)
* @LedruRollin (Cube-Xilam)
* @mathbou (Zag)
* @manuelrais (TNZPV)
* @NehmatH (CGWire)
* @pcharmoille (Unit Image)
* @Tilix4 (Normaal)
About authors
~~~~~~~~~~~~~
Kitsu is written by CGWire, a company based in France. We help with animation and
VFX studios to collaborate better through efficient tooling. We already work
with more than 70 studios around the world.
Visit `cg-wire.com <https://cg-wire.com>`__ for more information.
|CGWire Logo|
.. |CI badge| image:: https://github.com/cgwire/zou/actions/workflows/ci.yml/badge.svg
:target: https://github.com/cgwire/zou/actions/workflows/ci.yml
.. |Gitter badge| image:: https://badges.gitter.im/cgwire/Lobby.png
:target: https://gitter.im/cgwire/Lobby
.. |CGWire Logo| image:: https://zou.cg-wire.com/cgwire.png
:target: https://cgwire.com
.. |Downloads badge| image:: https://static.pepy.tech/personalized-badge/zou?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads
:target: https://pepy.tech/project/zou
.. |Discord badge| image:: https://badgen.net/badge/icon/discord?icon=discord&label
:target: https://discord.com/invite/VbCxtKN
| null | CG Wire | frank@cg-wire.com | null | null | GNU Affero General Public License v3 | animation, cg, asset, shot, api, cg production, asset management | [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Flask",
"Intended Audience :: Developers",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.1... | [] | https://zou.cg-wire.com | null | <3.15,>=3.10 | [] | [] | [] | [
"babel==2.18.0",
"click==8.3.1",
"discord.py==2.6.4",
"email-validator==2.3.0",
"ffmpeg-python==0.2.0",
"fido2==2.1.1",
"flasgger==0.9.7.1",
"flask_bcrypt==1.0.1",
"flask_caching==2.3.1",
"flask_fixtures==0.3.8",
"flask_mail==0.10.0",
"flask_principal==0.4.0",
"flask_restful==0.3.10",
"fla... | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T10:00:35.658124 | zou-1.0.14.tar.gz | 516,899 | f3/38/6e4eeb3e244df23f6045322461a81621830e521bd27b8956a2ba9c4f99e0/zou-1.0.14.tar.gz | source | sdist | null | false | e7fe1f77744013b4a0b30c1cf9ad9b48 | c9a2dfdb1f934789a29d09775ec0f5676d40f14f2f4261b85920ce5d2a5cfbee | f3386e4eeb3e244df23f6045322461a81621830e521bd27b8956a2ba9c4f99e0 | null | [
"LICENSE"
] | 305 |
2.4 | benchbro | 0.4.2 | Benchmark library and CLI | # benchbro
`benchbro` is a Python benchmarking library and CLI with pytest-style discovery and rich terminal output.
## Quick start
Install dependencies:
```bash
uv sync --group dev
```
Create benchmark cases in any importable module:
```python
from benchbro import Case
case = Case(name="hashing", case_type="cpu", metric_type="time", tags=["fast", "core"])
@case.input()
def payload() -> bytes:
return b"benchbro"
@case.benchmark()
def sha1(payload: bytes) -> str:
import hashlib
return hashlib.sha1(payload).hexdigest()
@case.benchmark()
def sha256(payload: bytes) -> str:
import hashlib
return hashlib.sha256(payload).hexdigest()
```
Regression thresholds default to `50.0` percent warning and `100.0` percent error at the case level, and can be overridden per benchmark:
```python
case = Case(name="hashing", warning_threshold_pct=5.0, regression_threshold_pct=10.0)
@case.benchmark(warning_threshold_pct=2.0, regression_threshold_pct=3.0)
def critical_path(payload: bytes) -> str:
...
```
Comparison metric can be configured at case-level and benchmark-level:
```python
case = Case(name="hashing", comparison_metric="p95_s")
@case.benchmark(comparison_metric="median_s")
def critical_path(payload: bytes) -> str:
...
```
Valid comparison metrics:
- time: `median_s` (default), `mean_s`, `iqr_s`, `p95_s`, `stddev_s`, `ops_per_sec`
- memory: `peak_alloc_bytes` (default), `net_alloc_bytes`, `peak_alloc_bytes_max`
GC is disabled during measured iterations by default. To keep the interpreter GC behavior unchanged, set:
```python
Case(name="hashing", gc_control="inherit")
```
Run benchmarks:
```bash
uv run benchbro --repeats 10 --warmup 2
```
When no target is provided, `benchbro` discovers benchmarks from:
- `benchmarks/**/*.py` (relative to repo root)
You can configure discovery in `pyproject.toml`:
```toml
[tool.benchbro.ini_options]
benchmark_paths = ["benchmarks"]
file_pattern = ["bench_*.py", "*_bench.py", "*benchmark.py", "*benchmarks.py"]
```
- `benchmark_paths`: directories to scan when no CLI target is provided
- `file_pattern`: glob pattern(s) for benchmark file names in directory discovery
`benchbro` compares against the baseline by default (`.benchbro/baseline.local.json`).
If the baseline is missing, benchbro creates it automatically.
If new cases/benchmarks are introduced later, missing entries are merged into baseline.
Pass `--new-baseline` to replace the entire baseline with the current run.
Pass `--ci` to use `.benchbro/baseline.ci.json` for baseline read/write/compare.
Pass `--no-compare` to skip comparison while still backfilling missing benchmark entries in baseline.
By default, regular runs do not write artifacts.
Use explicit output flags (`--output-json`, `--output-csv`, `--output-md`) when needed.
The baseline is always written to:
- `.benchbro/baseline.local.json` (default local mode)
- `.benchbro/baseline.ci.json` when using `--ci`
Recommended:
- ignore `.benchbro/` for machine-local benchmarking artifacts.
- commit `.benchbro/baseline.ci.json` for CI comparisons.
### Recommended `.gitignore`
```gitignore
# Benchbro local artifacts
.benchbro/*
!.benchbro/baseline.ci.json
```
If requested, markdown output can also be written with `--output-md`.
JSON artifacts include environment metadata for reproducibility (Python/runtime/platform/CPU fields) both at run level and on each benchmark entry.
## CLI basics
Run selected cases/tags and write outputs:
```bash
uv run benchbro my_benchmarks.py \
--case hashing \
--tag fast \
--output-json artifacts/current.json \
--output-csv artifacts/current.csv \
--output-md artifacts/current.md
```
Compare against baseline:
```bash
uv run benchbro my_benchmarks.py
```
Render time benchmark histograms in terminal output:
```bash
uv run benchbro my_benchmarks.py --histogram
```
Skip comparison for a run while still maintaining baseline structure:
```bash
uv run benchbro my_benchmarks.py --no-compare
```
Regression status uses each benchmark's effective thresholds (`benchmark override -> case threshold -> defaults`):
- warning default: `50%`
- error threshold default: `100%`
The comparison table shows warning and threshold values for each row.
Histograms are terminal-only in v1 and are shown for time benchmarks.
## End-to-end example
For a complete runnable workflow (baseline + candidate comparison), use:
- `examples/README.md`
- `make examples`
| text/markdown | Pete Daly | null | null | null | null | benchmarking, benchmark, performance, profiling, microbenchmark, latency, throughput, regression-testing, performance-testing, python, cli | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers"
] | [] | null | null | >=3.10 | [] | [] | [] | [
"rich",
"tomli; python_version < \"3.11\""
] | [] | [] | [] | [
"Repository, https://github.com/peter-daly/benchbro",
"Documentation, https://github.com/peter-daly/benchbro#readme"
] | 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-18T09:59:30.109650 | benchbro-0.4.2.tar.gz | 19,230 | fc/ab/da4b11fa1d1861e8104394ef46385a311944ed577b4c8835ce58747ad264/benchbro-0.4.2.tar.gz | source | sdist | null | false | a48c45dcaa22a9460994c8d5a1593173 | 816d5e716559a0633e7cc3d7622fd1d0c95520e22ae651571947255b725b37f0 | fcabda4b11fa1d1861e8104394ef46385a311944ed577b4c8835ce58747ad264 | MIT | [
"LICENSE"
] | 274 |
2.4 | agentberlin | 0.25.0 | Python SDK for Agent Berlin - AI-powered SEO and AEO automation | # Agent Berlin Python SDK
## Installation
```bash
pip install agentberlin
```
Agent Berlin Python SDK provides AI-powered SEO automation.
## Quick Start
```python
from agentberlin import AgentBerlin
client = AgentBerlin()
```
## Important Notes
1. Scripts should print their results or return values that can be captured
2. Use proper error handling with try/except blocks
## Available APIs
- **ga4**: `get()` - Traffic, visibility, and performance analytics
- **pages**: `advanced_page_search()`, `get()` - Search pages and get detailed page info
- **keywords**: `search()`, `list_clusters()`, `get_cluster_keywords()` - Search keywords, explore clusters
- **brand**: `get_profile()`, `update_profile()` - Brand profile management
- **google_cse**: `search()` - Google web search
- **serpapi**: `search()` - Multi-engine search with News, Images, Videos, Shopping
- **files**: `upload()` - Upload files to cloud storage
- **gsc**: `query()`, `get_site()`, `list_sitemaps()`, `get_sitemap()`, `inspect_url()` - Search analytics, sitemaps, URL inspection
- **reddit**: `get_subreddit_posts()`, `search()`, `get_post()`, `get_post_comments()`, `get_subreddit_info()` - Posts, comments, and subreddit info
- **bing_webmaster**: `get_query_stats()`, `get_page_stats()`, `get_traffic_stats()`, `get_crawl_stats()`, `get_site()` - Bing Webmaster Tools analytics
## API Reference
### ga4
Comprehensive analytics data from Google Analytics.
#### client.ga4.get()
Get GA4 analytics for the project.
Signature:
```python
analytics = client.ga4.get()
```
Returns Analytics object with:
- domain - The domain name
- domain_authority - Domain authority score (0-100)
- visibility.current_percentage - Current visibility percentage
- visibility.ranking_stability - Ranking stability score
- visibility.share_of_voice - Share of voice percentage
- visibility.history - List of VisibilityPoint(date, percentage)
- traffic.total_sessions - Total traffic sessions
- traffic.llm_sessions - Sessions from LLM sources
- traffic.channel_breakdown.direct - Direct traffic
- traffic.channel_breakdown.organic_search - Organic search traffic
- traffic.channel_breakdown.referral - Referral traffic
- traffic.channel_breakdown.organic_social - Social traffic
- traffic.channel_breakdown.llm - LLM-referred traffic
- traffic.daily_trend - List of DailyTraffic(date, sessions, llm_sessions)
- topics - List of TopicSummary(name, appearances, avg_position, topical_authority, trend)
- competitors - List of CompetitorSummary(name, visibility, share_of_voice)
- data_range.start - Data start date
- data_range.end - Data end date
- last_updated - Last update timestamp
### pages
A powerful search engine backed by yours and your competitors' crawled pages.
#### client.pages.advanced_page_search()
Advanced page search with multiple input modes.
This unified method supports three input modes (exactly one required):
- query: Simple text query for semantic search across all pages
- url: Find similar pages to an existing indexed page
- content: Find similar pages to provided raw content
Signature:
```python
# Query mode - semantic search
results = client.pages.advanced_page_search(
query="SEO best practices", # Text query for semantic search
count=10, # Max results (default: 10)
offset=0, # Pagination offset (default: 0)
similarity_threshold=0.60 # Min similarity 0-1 (default: 0.60)
)
# URL mode - find similar pages to an indexed page
results = client.pages.advanced_page_search(
url="https://example.com/blog/guide", # URL of indexed page
deep_search=True, # Include chunk-level analysis
count=10
)
# Content mode - find similar pages to raw content
results = client.pages.advanced_page_search(
content="This is my page content about SEO..."
)
# Query mode with filters
results = client.pages.advanced_page_search(
query="SEO guide",
domain="competitor.com", # Filter by domain
status_code="200", # Filter by HTTP status
topic="SEO", # Filter by topic name
page_type="pillar" # Filter by page type
)
```
Args:
- query: Text query for semantic search (mutually exclusive with url/content)
- url: URL of an indexed page (mutually exclusive with query/content)
- content: Raw content string (mutually exclusive with query/url)
- deep_search: If True and url provided, include chunk-level analysis. Note: Returns many results (page + chunk level) - best for finding internal linking opportunities, skip otherwise.
- count: Max recommendations (default: 10, max: 50)
- offset: Pagination offset (default: 0)
- similarity_threshold: Min similarity 0-1 (default: 0.60)
- domain: Filter by domain (e.g., "competitor.com")
- own_only: If True, filter to only your own pages (excludes competitors)
- status_code: Filter by HTTP status code ("200", "404", "error", "redirect", "success")
- topic: Filter by topic name
- page_type: Filter by page type ("pillar" or "landing")
Returns AdvancedPageSearchResponse with:
- source_page_url - URL of source page (only in URL mode)
- source_page_type - "pillar", "landing", or None
- source_assigned_topic - Topic if page is assigned as pillar/landing
- page_recommendations - List of PageRecommendation objects
- chunk_recommendations - List of ChunkRecommendationSet (only with deep_search)
Each PageRecommendation has:
- target_page_url - URL of recommended page
- similarity_score - Similarity score 0-1
- match_type - "page_to_page" or "chunk_to_page"
- chunk_text - Source chunk text (for chunk_to_page matches)
- page_type - "pillar", "landing", or None
- assigned_topic - Topic if target is assigned as pillar/landing
- title - Page title
- h1 - H1 heading
- meta_description - Meta description
- evidence - List of Evidence objects (h_path, text) for top chunks
- domain - Page domain
- status_code - HTTP status code
- topic_info - TopicInfo object (topics, topic_scores, page_type, assigned_topic)
#### client.pages.get()
Get detailed page information.
Signature:
```python
page = client.pages.get(
url="https://example.com/blog/article",
content_length=500 # Optional: include content preview (0 = no content)
)
```
Returns PageDetailResponse with:
- url - Page URL
- title - Page title
- meta_description - Meta description
- h1 - H1 heading
- domain - Domain name
- links.inlinks - List of incoming links (PageLink objects)
- links.outlinks - List of outgoing links (PageLink objects)
- topic_info.topics - List of topic names
- topic_info.topic_scores - List of topic relevance scores
- topic_info.page_type - "pillar" or "landing"
- topic_info.assigned_topic - Primary assigned topic
- content_preview - Content preview (if content_length > 0)
- content_length - Total content length
### keywords
Search for keywords and explore keyword clusters (powered by SEMRush & DataForSEO)
#### client.keywords.search()
Search for keywords.
Signature:
```python
keywords = client.keywords.search(
query="digital marketing", # Semantic search query
limit=10 # Max results (default: 10)
)
```
Returns KeywordSearchResponse with keywords list and total count.
Each keyword has:
- keyword - The keyword text
- volume - Monthly search volume
- difficulty - Difficulty score (0-100)
- cpc - Cost per click
- intent - Search intent: "informational", "commercial", "transactional", "navigational"
#### client.keywords.list_clusters()
List all keyword clusters with representative keywords.
Keywords are grouped into clusters using HDBSCAN clustering based on semantic similarity.
This method returns a summary of all clusters for topic exploration.
Signature:
```python
clusters = client.keywords.list_clusters(
representative_count=3 # Keywords per cluster (default: 3, max: 10)
)
```
Returns ClusterListResponse with:
- clusters - List of ClusterSummary objects
- noise_count - Number of unclustered keywords (cluster_id=-1)
- total_keywords - Total keywords in the index
- cluster_count - Number of clusters (excluding noise)
Each ClusterSummary has:
- cluster_id - Unique cluster identifier
- size - Number of keywords in cluster
- representative_keywords - Top keywords by volume
Example:
```python
clusters = client.keywords.list_clusters()
for cluster in clusters.clusters:
print(f"Cluster {cluster.cluster_id}: {cluster.size} keywords")
print(f" Topics: {', '.join(cluster.representative_keywords)}")
```
#### client.keywords.get_cluster_keywords()
Get keywords belonging to a specific cluster.
Use this to explore keywords within a cluster. Supports pagination for large clusters.
Use cluster_id=-1 to get noise (unclustered) keywords.
Signature:
```python
result = client.keywords.get_cluster_keywords(
cluster_id=0, # Required: cluster ID (-1 for noise)
limit=50, # Max keywords (default: 50, max: 1000)
offset=0 # Pagination offset (default: 0)
)
```
Returns ClusterKeywordsResponse with:
- keywords - List of ClusterKeywordResult objects
- total - Total keywords in this cluster
- cluster_id - The requested cluster ID
- limit - Limit used
- offset - Offset used
Each ClusterKeywordResult has:
- keyword - The keyword text
- cluster_id - Cluster ID
- volume - Monthly search volume (optional)
- difficulty - Difficulty score 0-100 (optional)
- cpc - Cost per click (optional)
- intent - Search intent (optional)
Example:
```python
# Get top keywords from cluster 0
result = client.keywords.get_cluster_keywords(0, limit=20)
for kw in result.keywords:
print(f"{kw.keyword}: volume={kw.volume}")
# Get noise keywords (unclustered)
noise = client.keywords.get_cluster_keywords(-1, limit=100)
```
### brand
Your brand profile including company info, competitors, industries, and target markets.
#### client.brand.get_profile()
Get the complete brand profile including all company information, competitors, target industries, business models, and geographic scope.
Signature:
```python
profile = client.brand.get_profile()
```
Returns BrandProfileResponse with:
- domain - Domain name
- name - Brand name
- context - Brand context/description
- search_analysis_context - Search analysis context
- domain_authority - Domain authority score
- competitors - List of competitor domains
- industries - List of industries
- business_models - List of business models
- company_size - Company size
- target_customer_segments - Target segments
- geographies - Target geographies
- personas - List of persona strings
- topics - List of Topic objects (value, pillar_page_url, landing_page_url)
- sitemaps - Sitemap URLs
- profile_urls - Profile URLs
Example:
```python
profile = client.brand.get_profile()
print(f"Domain: {profile.domain}")
print(f"Personas: {profile.personas}")
print(f"Topics: {[(t.value, t.pillar_page_url) for t in profile.topics]}")
```
#### client.brand.update_profile()
Update brand profile fields.
**Important behavior:**
- Only provided fields are updated
- Fields set to None/undefined are IGNORED (not cleared)
- To clear a list field, pass an empty list []
- To clear a string field, pass an empty string ""
Signature:
```python
result = client.brand.update_profile(
name="Project Name", # Optional: Project name
context="Business description...", # Optional: Business context
competitors=["competitor1.com"], # Optional: Competitor domains
industries=["SaaS", "Technology"], # Optional: Industries
business_models=["B2B", "Enterprise"], # Optional: Business models
company_size="startup", # Optional: solo, early_startup, startup, smb, mid_market, enterprise
target_customer_segments=["Enterprise"], # Optional: Target segments
geographies=["US", "EU"], # Optional: Geographic regions
personas=["Enterprise buyer", "Tech lead"], # Optional: Persona descriptions
topics=["SEO", "Content Marketing"] # Optional: Topic values
)
```
Returns BrandProfileUpdateResponse with:
- success - Boolean indicating success
- profile - Updated BrandProfileResponse with all fields
Examples:
```python
# Update multiple fields at once
result = client.brand.update_profile(
context="We are a B2B SaaS company...",
competitors=["competitor1.com", "competitor2.com"],
personas=["Enterprise buyers", "Technical decision makers"],
topics=["SEO", "Content Marketing", "Analytics"]
)
# Only update one field (others unchanged)
result = client.brand.update_profile(industries=["SaaS", "MarTech"])
# Clear a list field
result = client.brand.update_profile(competitors=[])
```
### google_cse
Simple, fast Google web searches.
#### client.google_cse.search()
Search Google.
Signature:
```python
results = client.google_cse.search(
query="best seo tools",
max_results=10, # Max results (1-10, default: 10)
country="us", # Optional: ISO 3166-1 alpha-2 country code
language="lang_en" # Optional: ISO 639-1 with "lang_" prefix
)
```
Returns GoogleCSEResponse with:
- query - The search query
- results - List of GoogleCSEResult objects
- total - Total results count
Each result has: title, url, snippet
### serpapi
Multi-engine search supporting Google and Bing with News, Videos, Images, and Shopping.
#### client.serpapi.search()
Multi-engine search.
Signature:
```python
results = client.serpapi.search(
query="best seo tools", # Required: The search query
engine="google", # "google" or "bing" (default: "google")
search_type="web", # "web", "news", "images", "videos", "shopping" (default: "web")
device="desktop", # Optional: "desktop", "tablet", or "mobile"
country="us", # Optional: ISO 3166-1 alpha-2 country code
language="en", # Optional: ISO 639-1 language code
max_results=10 # Number of results, 1-100 (default: 10)
)
```
Note: news, images, videos, shopping search types are Google only.
Examples:
```python
# Bing web search
results = client.serpapi.search(query="best seo tools", engine="bing", country="us")
# Google News search
results = client.serpapi.search(query="AI technology", search_type="news", country="us")
# Google Images search
results = client.serpapi.search(query="modern website design", search_type="images")
# Google Shopping search
results = client.serpapi.search(query="wireless headphones", search_type="shopping")
```
Returns SerpApiResponse with:
- query - The search query
- engine - Search engine used
- search_type - Type of search performed
- results - List of SerpApiResult objects
- total - Total results count
- search_metadata - Optional metadata (id, status, total_time_taken)
Each result has: title, url, snippet, displayed_link, date, thumbnail
### files
Upload files to cloud storage (auto-deleted after 365 days)
#### client.files.upload()
Upload files to cloud storage.
Signature:
```python
# Upload from string content (must encode to bytes)
csv_content = "url,title\nhttps://example.com,Example"
result = client.files.upload(
file_data=csv_content.encode(), # Must be bytes, not string
filename="report.csv"
)
# Upload from file path
result = client.files.upload(file_path="/path/to/file.csv")
# Upload with explicit content type
result = client.files.upload(
file_data=b'{"key": "value"}',
filename="data.json",
content_type="application/json"
)
```
Allowed content types: text/plain, text/csv, text/markdown, text/html, text/css, text/javascript, application/json, application/xml
Returns FileUploadResponse with:
- file_id - Unique file identifier
- filename - The filename
- content_type - MIME type
- size - File size in bytes
- url - Download URL
### gsc
Access your Google Search Console data including search analytics, sitemaps, and URL inspection.
#### client.gsc.query()
Query search analytics data.
Signature:
```python
result = client.gsc.query(
start_date="2024-01-01",
end_date="2024-01-31",
dimensions=["query", "page"], # Optional: "query", "page", "country", "device", "searchAppearance", "date"
search_type="web", # Optional: "web", "image", "video", "news", "discover", "googleNews"
row_limit=100, # Optional: max rows (default 1000, max 25000)
start_row=0, # Optional: pagination offset
aggregation_type="auto", # Optional: "auto", "byPage", "byProperty"
data_state="final" # Optional: "final", "all"
)
```
Returns SearchAnalyticsResponse with:
- rows - List of SearchAnalyticsRow objects
- response_aggregation_type - How data was aggregated
Each row has: keys (list), clicks, impressions, ctr, position
### Pagination Example
The Search Console API returns max 25,000 rows per request. For large datasets:
```python
def get_all_search_analytics(start_date: str, end_date: str, dimensions: list):
"""Fetch all search analytics data with automatic pagination."""
all_rows = []
start_row = 0
row_limit = 25000 # Maximum allowed by the API
while True:
result = client.gsc.query(
start_date=start_date,
end_date=end_date,
dimensions=dimensions,
row_limit=row_limit,
start_row=start_row,
)
all_rows.extend(result.rows)
# If we got fewer rows than requested, we've reached the end
if len(result.rows) < row_limit:
break
start_row += row_limit
return all_rows
```
Note: The API has daily quota limits. For large datasets, consider reducing the date range or using fewer dimensions.
#### client.gsc.get_site()
Get site information.
Signature:
```python
site = client.gsc.get_site()
```
Returns SiteInfo with:
- site_url - The site URL
- permission_level - Permission level (e.g., "siteOwner")
#### client.gsc.list_sitemaps()
List all sitemaps.
Signature:
```python
sitemaps = client.gsc.list_sitemaps()
```
Returns SitemapListResponse with:
- sitemap - List of Sitemap objects
Each sitemap has: path, last_submitted, is_pending, is_sitemaps_index, last_downloaded, warnings, errors, contents
#### client.gsc.get_sitemap()
Get specific sitemap details.
Signature:
```python
sitemap = client.gsc.get_sitemap("https://example.com/sitemap.xml")
```
Returns Sitemap with full details.
#### client.gsc.inspect_url()
Inspect a URL's index status.
Signature:
```python
inspection = client.gsc.inspect_url(
url="https://example.com/page",
language_code="en-US" # Optional: for localized results
)
```
Returns UrlInspectionResponse with:
- inspection_result.inspection_result_link - Link to GSC
- inspection_result.index_status_result - Index status details
- inspection_result.mobile_usability_result - Mobile usability
- inspection_result.rich_results_result - Rich results info
### reddit
Access live Reddit data (posts, comments, and subreddit info).
#### client.reddit.get_subreddit_posts()
Fetch posts from a subreddit.
Signature:
```python
posts = client.reddit.get_subreddit_posts(
subreddit="programming", # Required: subreddit name (without /r/)
sort="hot", # Optional: "hot", "new", "top", "rising" (default: "hot")
time_filter="week", # Optional: "hour", "day", "week", "month", "year", "all" (for "top" sort)
limit=25, # Optional: max posts 1-100 (default: 25)
after="t3_abc123" # Optional: pagination cursor from previous response
)
```
Returns SubredditPostsResponse with:
- posts - List of RedditPost objects
- after - Pagination cursor for next page (None if no more results)
Each RedditPost has:
- id - Post ID
- title - Post title
- author - Author username
- subreddit - Subreddit name
- score - Net upvotes
- upvote_ratio - Ratio of upvotes (0-1)
- num_comments - Comment count
- created - Creation datetime
- url - Link URL (or permalink for self posts)
- permalink - Reddit permalink
- is_self - True if text post
- selftext - Post body (for self posts)
- domain - Link domain
- nsfw - True if NSFW
- spoiler - True if marked spoiler
- locked - True if comments locked
- stickied - True if pinned
#### client.reddit.search()
Search Reddit posts.
Signature:
```python
results = client.reddit.search(
query="python async", # Required: search query
subreddit="learnprogramming", # Optional: restrict to subreddit
sort="relevance", # Optional: "relevance", "hot", "top", "new", "comments" (default: "relevance")
time_filter="month", # Optional: "hour", "day", "week", "month", "year", "all"
limit=25, # Optional: max results 1-100 (default: 25)
after="t3_abc123" # Optional: pagination cursor
)
```
Returns RedditSearchResponse with:
- query - The search query
- posts - List of RedditPost objects
- after - Pagination cursor for next page
#### client.reddit.get_post()
Get a single post by ID.
Signature:
```python
post = client.reddit.get_post("abc123") # Post ID with or without t3_ prefix
```
Returns RedditPost with full post details.
#### client.reddit.get_post_comments()
Get comments on a post.
Signature:
```python
response = client.reddit.get_post_comments(
post_id="abc123", # Required: post ID (with or without t3_ prefix)
sort="best", # Optional: "best", "top", "new", "controversial", "old" (default: "best")
limit=50 # Optional: max comments 1-500 (default: 50)
)
```
Returns PostCommentsResponse with:
- post - RedditPost object with full post details
- comments - List of RedditComment objects (nested with replies)
Each RedditComment has:
- id - Comment ID
- author - Author username
- body - Comment text
- score - Net upvotes
- created - Creation datetime
- permalink - Reddit permalink
- depth - Nesting depth (0 = top-level)
- is_op - True if author is the post author
- replies - List of nested RedditComment objects
#### client.reddit.get_subreddit_info()
Get subreddit metadata.
Signature:
```python
info = client.reddit.get_subreddit_info("programming")
```
Returns SubredditInfo with:
- name - Subreddit name (display_name)
- title - Subreddit title
- description - Full description (markdown)
- public_description - Short public description
- subscribers - Subscriber count
- active_users - Currently active users
- created - Creation datetime
- nsfw - True if NSFW
- icon_url - Subreddit icon URL (optional)
- banner_url - Banner image URL (optional)
### bing_webmaster
Access Bing Webmaster Tools data including search analytics, page performance, traffic stats, and crawl information.
#### client.bing_webmaster.get_query_stats()
Get search query statistics.
Returns search query analytics including impressions, clicks,
average position, and CTR for queries that triggered your site.
Signature:
```python
result = client.bing_webmaster.get_query_stats()
```
Returns QueryStatsResponse with:
- rows - List of QueryStatsRow objects
Each QueryStatsRow has:
- query - The search query
- impressions - Number of impressions
- clicks - Number of clicks
- avg_position - Average position in search results
- avg_ctr - Average click-through rate
- date - Date of the data (optional)
#### client.bing_webmaster.get_page_stats()
Get page-level statistics.
Returns page-level analytics including impressions, clicks,
average position, and CTR for your pages.
Signature:
```python
result = client.bing_webmaster.get_page_stats()
```
Returns PageStatsResponse with:
- rows - List of PageStatsRow objects
Each PageStatsRow has:
- url - The page URL
- impressions - Number of impressions
- clicks - Number of clicks
- avg_position - Average position in search results
- avg_ctr - Average click-through rate
#### client.bing_webmaster.get_traffic_stats()
Get overall traffic statistics.
Returns aggregate traffic metrics for your site.
Signature:
```python
traffic = client.bing_webmaster.get_traffic_stats()
```
Returns TrafficStats with:
- date - Date of the data (optional)
- impressions - Total impressions
- clicks - Total clicks
- avg_ctr - Average click-through rate
- avg_imp_rank - Average impression rank
- avg_click_position - Average click position
#### client.bing_webmaster.get_crawl_stats()
Get crawl statistics.
Returns crawl metrics including pages crawled, errors,
indexing status, and various crawl issues.
Signature:
```python
crawl = client.bing_webmaster.get_crawl_stats()
```
Returns CrawlStats with:
- date - Date of the data (optional)
- crawled_pages - Number of pages crawled
- crawl_errors - Number of crawl errors
- in_index - Number of pages in the index
- in_links - Number of inbound links
- blocked_by_robots_txt - Pages blocked by robots.txt
- contains_malware - Pages flagged for malware
- http_code_error - Pages with HTTP errors
#### client.bing_webmaster.get_site()
Get site information.
Returns the site URL and verification status for the site
associated with the current project.
Signature:
```python
site = client.bing_webmaster.get_site()
```
Returns SiteInfo with:
- site_url - The site URL
- is_verified - Whether the site is verified
- is_in_index - Whether the site is in the Bing index
| text/markdown | null | Agent Berlin <support@agentberlin.ai> | null | null | MIT | aeo, ai, analytics, optimization, search, seo | [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Py... | [] | null | null | >=3.9 | [] | [] | [] | [
"pydantic>=2.0.0",
"requests>=2.28.0",
"black>=24.0.0; extra == \"dev\"",
"isort>=5.13.0; extra == \"dev\"",
"mypy>=1.8.0; extra == \"dev\"",
"pytest-cov>=4.1.0; extra == \"dev\"",
"pytest>=8.0.0; extra == \"dev\"",
"responses>=0.25.0; extra == \"dev\"",
"types-requests>=2.31.0; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://agentberlin.ai",
"Documentation, https://docs.agentberlin.ai/sdk/python",
"Repository, https://github.com/boat-builder/agentberlin"
] | 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-18T09:59:01.048725 | agentberlin-0.25.0.tar.gz | 35,145 | 22/db/b23b51be32006dd714bd0e5b334834172d4be68f6335ba6b8bb39c356efa/agentberlin-0.25.0.tar.gz | source | sdist | null | false | ece512a22be1b8b79847a9dad76b22a8 | d4ffd6704baef5d69dbac2de7acf49a93f6cfd8d37be2d79252655ac07fb5dc8 | 22dbb23b51be32006dd714bd0e5b334834172d4be68f6335ba6b8bb39c356efa | null | [
"LICENSE"
] | 253 |
2.4 | bazis | 2.2.4 | A JsonAPI framework based on Django + FastAPI + Pydantic. | # Bazis
[](https://pypi.org/project/bazis/)
[](https://pypi.org/project/bazis/)
[](https://opensource.org/licenses/Apache-2.0)
A framework for rapid API development that combines the capabilities of Django and FastAPI to create flexible and high-performance solutions.
## Quick Start
```bash
# Install the package
uv add bazis
# Create a model
from bazis.core.models_abstract import InitialBase
from django.db import models
class Organization(InitialBase):
name = models.CharField(max_length=255)
# Create a route
from bazis.core.routes_abstract.jsonapi import JsonapiRouteBase
from django.apps import apps
class OrganizationRouteSet(JsonapiRouteBase):
model = apps.get_model('myapp.Organization')
```
## Table of Contents
- [Description](#description)
- [Core Concept](#core-concept)
- [Features](#features)
- [Requirements](#requirements)
- [Installation](#installation)
- [Deployment](#deployment)
- [Auto-Documentation](#auto-documentation)
- [Usage](#usage)
- [Creating Models](#creating-models)
- [Creating Routes](#creating-routes)
- [Registering Routes](#registering-routes)
- [Project Configuration](#project-configuration)
- [API Features](#api-features)
- [Data Schema Analysis](#data-schema-analysis)
- [Filtering](#filtering)
- [Included Resources (JSON:API)](#included-resources-jsonapi)
- [Error Format](#error-format)
- [Examples](#examples)
- [Architecture](#architecture)
- [Development](#development)
- [Contributing](#contributing)
- [License](#license)
- [Links](#links)
## Description
**Bazis** is a framework designed for rapid API development. It combines the capabilities of Django and FastAPI to provide a flexible and reliable solution for creating APIs. Django is used as the foundation for ORM and the administrative panel, while FastAPI ensures high performance when handling API requests.
**This package serves as the core for other Bazis family packages.**
To add additional functionality, you can use packages named `bazis-<n>`. All of these packages will require this core package.
## Core Concept
The **Bazis** framework is built around combining Django's ORM capabilities with FastAPI's high-performance API handling. This hybrid approach allows developers to utilize Django's robust database management tools and admin interface while benefiting from the speed and simplicity of FastAPI.
The central entity in a project built using Bazis is the Django model. Once its fields are defined, it provides enough information to generate a working CRUD API. For describing the API, the OpenAPI protocol is a perfect fit, into which Pydantic schemas can be automatically converted.
Thus, the framework's task is to transform model and route definitions into Pydantic schemas.
In Bazis, these Pydantic schemas are generated as follows:
- A route class is declared, specifying the target model
- Optionally, field restrictions can be defined
- Specific CRUD operations for the route can be optionally specified
- Input and output Pydantic schemas are generated based on the route and related model
## Features
- **Hybrid Framework**: Combines Django and FastAPI
- **JSON:API Specification**: Adheres to the JSON:API specification for building APIs
- **Class-Based Routes**: Routes are defined as class methods
- **Modular Design**: Easily extendable and customizable
- **Settings Management System**: Implementation via `django.conf.settings` with support for environment variables and admin panel
- **Automatic Schema Generation**: Pydantic schemas are automatically generated based on Django models
- **Nested Structures Support**: Thanks to JSON:API, includes support for `included`, multi-level filtering, and more
- **Dynamic Fields**: Flexible field configuration at the route level
- **High Performance**: FastAPI's asynchronous capabilities provide low latency
- **Calculated Fields**: Powerful system for working with related data via `@calc_property` decorator
## Advantages Over Other Solutions
1. **Performance**: FastAPI's asynchronous capabilities provide high performance and low latency
2. **Flexibility**: Combines the best aspects of Django and FastAPI
3. **Ease of Use**: Simplifies the development process through class-based routes and dependency injection
4. **Scalability**: Designed to handle large-scale applications
5. **Standards Compliance**: Adheres to JSON:API and OpenAPI specifications to ensure consistency and interoperability
## Requirements
- **Python**: 3.12+
- **PostgreSQL**: 12+
- **Redis**: For caching
> **Note!** The current implementation of the framework requires **Redis** as the cache backend and **PostgreSQL** as the database.
## Installation
### Using uv (recommended)
```bash
uv add bazis
```
### Using pip
```bash
pip install bazis
```
### For development
```bash
git clone git@github.com:ecofuture-tech/bazis.git
cd bazis
uv sync --dev
```
## Deployment
The backend consists of 2 services:
- API service
- Admin service
### Deployment Scripts
- `deploy/run/app_init.sh` - initialization procedures
- `deploy/run/app.sh` - start API service
- `deploy/run/admin.sh` - start admin service
- `deploy/run/tests.sh` - run tests
### Gunicorn Configs
- `deploy/config/app.py` - API service config
- `deploy/config/admin.py` - admin service config
### Environment Variables
Required environment variables:
- `BS_DEBUG` - debug mode
- `BS_DB_HOST` - database host
- `BS_DB_PORT` - database port
- `BS_DB_NAME` - database name
- `BS_DB_USER` - database user
- `BS_DB_PASSWORD` - database password
- `BS_MEDIA_ROOT` - full path to media files folder
- `BS_STATIC_ROOT` - full path to static files folder
- `BS_APP_PORT` - API service port
- `BS_ADMIN_PORT` - admin service port
- `BS_MEDIA_URL` - absolute URL for media files folder
- `BS_STATIC_URL` - absolute URL for static files folder
- `BS_ADMIN_NAME` - admin username for admin service
- `BS_ADMIN_PASSWORD` - admin password for admin service
## Auto-Documentation
### Swagger UI
Available at `/api/swagger/`
Features:
- Ability to authenticate and execute requests
- Click the "Authorize" button
- Enter username and password (leave other fields empty)
- List of all endpoints with schemas displayed below
### ReDoc
Available at `/api/redoc/`
Features:
- More readable endpoint documentation
- Does not allow request execution
## Usage
### Creating Models
Create models by inheriting from base classes:
```python
from bazis.core.models_abstract import InitialBase, DtMixin, UuidMixin, JsonApiMixin
from django.db import models
class VehicleBrand(DtMixin, UuidMixin, JsonApiMixin):
"""Vehicle brand."""
name = models.CharField('Brand Name', max_length=255, unique=True)
class Meta:
verbose_name = 'Vehicle Brand'
verbose_name_plural = 'Vehicle Brands'
def __str__(self):
return self.name
```
> **Important!** Every model and mixin must inherit from `bazis.core.models_abstract.InitialBase`.
**Example model with Foreign Key:**
```python
class VehicleModel(DtMixin, UuidMixin, JsonApiMixin):
"""Vehicle model."""
brand = models.ForeignKey(VehicleBrand, verbose_name='Brand', on_delete=models.CASCADE)
model = models.CharField('Model', max_length=255, unique=True)
engine_type = models.CharField('Engine Type', max_length=50, null=True, blank=True)
capacity = models.DecimalField(
'Capacity, t', max_digits=6, decimal_places=2, null=True, blank=True
)
class Meta:
verbose_name = 'Vehicle Model'
verbose_name_plural = 'Vehicle Models'
unique_together = ('brand', 'model')
def __str__(self):
return self.model
```
**Example model with ManyToMany:**
```python
class Driver(DtMixin, UuidMixin, JsonApiMixin):
"""Driver."""
first_name = models.CharField('First Name', max_length=255)
last_name = models.CharField('Last Name', max_length=255)
contact_phone = models.CharField('Phone', max_length=50, null=True, blank=True)
divisions = models.ManyToManyField(
'Division',
related_name='drivers',
blank=True,
)
org_owner = models.ForeignKey(
'Organization',
blank=True,
null=True,
db_index=True,
on_delete=models.SET_NULL,
)
class Meta:
verbose_name = 'Driver'
verbose_name_plural = 'Drivers'
def __str__(self):
return f'{self.first_name} {self.last_name}'
```
**Example model with OneToOne:**
```python
class ExtendedEntity(ExtendedEntityBase, DtMixin, UuidMixin, JsonApiMixin):
parent_entity = models.OneToOneField(
'ParentEntity', on_delete=models.CASCADE, related_name='extended_entity'
)
```
**Example model with calculated field:**
```python
from decimal import Decimal
from bazis.core.utils.orm import calc_property, FieldRelated
from bazis.core.utils.functools import get_attr
class Vehicle(DtMixin, UuidMixin, JsonApiMixin):
"""Vehicle with calculated fields."""
vehicle_model = models.ForeignKey(
VehicleModel, verbose_name='Vehicle Model', on_delete=models.CASCADE
)
country = models.ForeignKey(Country, verbose_name='Country', on_delete=models.CASCADE)
gnum = models.CharField('State Registration Number', max_length=50, unique=True)
@calc_property([FieldRelated('vehicle_model')])
def vehicle_capacity(self) -> Decimal:
return get_attr(self, 'vehicle_model.capacity', Decimal(0.00))
class Meta:
verbose_name = 'Vehicle'
verbose_name_plural = 'Vehicles'
def __str__(self):
return self.gnum
```
### Creating Routes
Create routes for your models:
```python
from django.apps import apps
from bazis.core.routes_abstract.jsonapi import JsonapiRouteBase
class VehicleBrandRouteSet(JsonapiRouteBase):
"""Route for VehicleBrand"""
model = apps.get_model('entity.VehicleBrand')
```
**Route with additional fields:**
```python
from bazis.core.schemas.fields import SchemaField, SchemaFields
class ParentEntityRouteSet(JsonapiRouteBase):
model = apps.get_model('entity.ParentEntity')
# Add fields (extended_entity, dependent_entities and calculated properties) to schema
fields = {
None: SchemaFields(
include={
'extended_entity': None,
'dependent_entities': None,
'active_children': SchemaField(source='active_children', required=False),
'count_active_children': SchemaField(
source='count_active_children', required=False
),
'has_inactive_children': SchemaField(
source='has_inactive_children', required=False
),
'extended_entity_price': SchemaField(
source='extended_entity_price', required=False
),
},
),
}
```
**Route with ManyToMany relationship inclusion:**
```python
class ChildEntityRouteSet(JsonapiRouteBase):
model = apps.get_model('entity.ChildEntity')
fields = {
None: SchemaFields(
include={
'parent_entities': None, # ManyToMany relationship
},
),
}
```
### Registering Routes
**Creating router.py in your application:**
```python
from bazis.core.routing import BazisRouter
from . import routes
# Main router with tags for grouping
router = BazisRouter(tags=['Entity'])
router.register(routes.ChildEntityRouteSet.as_router())
router.register(routes.DependentEntityRouteSet.as_router())
router.register(routes.ExtendedEntityRouteSet.as_router())
router.register(routes.ParentEntityRouteSet.as_router())
router.register(routes.VehicleModelRouteSet.as_router())
router.register(routes.VehicleBrandRouteSet.as_router())
router.register(routes.CountryRouteSet.as_router())
router.register(routes.CarrierTaskRouteSet.as_router())
router.register(routes.DivisionJsonRouteSet.as_router())
router.register(routes.DriverRouteSet.as_router())
# Create specialized routers with prefixes
router_context = BazisRouter(tags=['Context'])
router_context.register(routes.DriverContextRouteSet.as_router())
router_json = BazisRouter(tags=['Json'])
router_json.register(routes.DriverJsonHierarchyRouteSet.as_router())
router_json.register(routes.VehicleJsonRouteSet.as_router())
router_related = BazisRouter(tags=['Related'])
router_related.register(routes.VehicleRelatedRouteSet.as_router())
# Dictionary of routers with prefixes
routers_with_prefix = {
'context': router_context,
'json': router_json,
'related': router_related,
}
```
**Main project router.py:**
```python
from bazis.core.routing import BazisRouter
router = BazisRouter(prefix='/api/v1')
# Register application modules
router.register('entity.router')
router.register('dynamic.router')
router.register('route_injection.router')
router.register('sparse_fieldsets.router')
```
### Project Configuration
The settings management system is implemented through `django.conf.settings`. Values can be set either via environment variables or in the admin panel.
Each Bazis application defines a `conf.py` module containing a Pydantic `Settings` schema with configuration fields.
Example `conf.py`:
```python
from pydantic import BaseSettings
class Settings(BaseSettings):
debug: bool = False
secret_key: str
database_url: str
class Config:
env_prefix = 'BS_'
```
## API Features
### Data Schema Analysis
#### OpenAPI Schema
- Primary API analysis (endpoints, attributes) can be obtained from `/api/openapi.json`
- When making requests as an authenticated user, some fields may be removed or have different access levels
- For each CRUD action, you can request the actual schema:
- Schemas are provided in OpenAPI format
- Available schemas:
- `schema_list` - schema for listing items
- `schema_create` - schema for creating items
- `{item_id}/schema_retrieve` - schema for retrieving specific item
- `{item_id}/schema_update` - schema for updating specific item
#### Field Attributes
- `required` - required fields
- `title` - human-readable name
- `description` - extended field description
- `nullable` - when true, field can accept "null" value
- `readOnly` - field is read-only
- `writeOnly` - field is write-only
- `enum` - list of values the field can accept
- `enumDict` - dictionary mapping values to human-readable names
- `format` - non-standard field format
- `minLength` - minimum allowed string length
- `maxLength` - maximum allowed string length
- `filterLabel` - field can be used in filtering with specified label
### Filtering
The framework provides powerful filtering capabilities through query parameters:
#### Filter Types
**Exact Match:**
```
# Single value
?filter[type]=FIRST
# Multiple values
?filter[type]=FIRST&filter[type]=SECOND
```
**Boolean Values:**
```
# False value
?filter[is_active]=false
# True value (anything except 'false')
?filter[is_active]=true
```
**Range Filters:**
Available for numeric and datetime fields with postfixes:
- `gt` - greater than
- `gte` - greater than or equal
- `lt` - less than
- `lte` - less than or equal
Examples:
```
?filter[dt_created__gte]=2022-05-16
?filter[price__lt]=5.2
```
**Nested Filters:**
For fields defined in the relationships block:
1. Determine the type of nested object
2. Find the nested object schema
3. Get fields available for filtering
Example:
```
# For organization.organization type
?filter[org_owner__tin]=7845612348
```
**Full-Text Search:**
Use the `$search` modifier for full-text search:
```
# Search in nested relationships (two levels deep)
?filter[facility_operations__fkkos__$search]=test
# Search in root results
?filter[$search]=test
```
### Included Resources (JSON:API)
Bazis implements the JSON:API specification for handling related resources through the `included` feature, allowing you to fetch related data in a single request.
### Error Format
- Expected errors return status code `422`
- Error message format follows JSON:API specification
## Examples
### Basic Route Usage
```python
from django.apps import apps
from bazis.core.routes_abstract.jsonapi import JsonapiRouteBase
from bazis.core.routing import BazisRouter
class VehicleRouteSet(JsonapiRouteBase):
model = apps.get_model('entity.Vehicle')
# All CRUD operations are available by default
router = BazisRouter(tags=['Vehicles'])
router.register(VehicleRouteSet.as_router())
```
### Limiting Fields in Routes
```python
from bazis.core.schemas.fields import SchemaFields
class VehicleRouteSet(JsonapiRouteBase):
model = apps.get_model('entity.Vehicle')
fields = {
None: SchemaFields(
include={
# Specify only needed fields
'gnum': None,
'vehicle_model': None,
'country': None,
},
),
}
```
### Adding Calculated Fields to API
```python
from bazis.core.schemas.fields import SchemaField, SchemaFields
class VehicleRelatedRouteSet(JsonapiRouteBase):
model = apps.get_model('entity.Vehicle')
fields = {
None: SchemaFields(
include={
# FieldRelated - vehicle_capacity
'vehicle_capacity_1': SchemaField(source='vehicle_capacity_1', required=False),
'vehicle_capacity_2': SchemaField(source='vehicle_capacity_2', required=False),
'vehicle_capacity_3': SchemaField(source='vehicle_capacity_3', required=False),
# FieldRelated - brand, multiple fields
'brand_info': SchemaField(source='brand_info', required=False),
# FieldRelated - brand and country
'brand_and_country': SchemaField(source='brand_and_country', required=False),
},
),
}
```
### Working with Admin Panel
```python
from django.contrib import admin
from bazis.core.admin_abstract import DtAdminMixin
@admin.register(VehicleBrand)
class VehicleBrandAdmin(DtAdminMixin, admin.ModelAdmin):
list_display = ('id', 'name')
search_fields = ('name',)
```
**Admin with inline models:**
```python
class ChildEntityInline(admin.TabularInline):
model = ParentEntity.child_entities.through
extra = 0
class DependentEntityInline(admin.TabularInline):
model = DependentEntity
extra = 0
@admin.register(ParentEntity)
class ParentEntityAdmin(DtAdminMixin, admin.ModelAdmin):
list_display = ('id', 'name', 'is_active')
list_filter = ('is_active',)
search_fields = ('name', 'description')
inlines = (ChildEntityInline, DependentEntityInline)
```
## Architecture
### Package Structure
The **bazis** package is the core project installed under the `bazis.core` namespace.
Extension packages are installed under the `bazis.contrib` namespace.
### Application Structure
All files are optional:
```
app/
├── models_abstract.py # Mixins or abstractions for creating models
├── admin_abstract.py # Mixins for creating admin classes
├── routes_abstract.py # Mixins and base classes for routes
├── models.py # Actual application models
├── admin.py # Admin classes
├── routes.py # Route classes
├── router.py # URL routing
├── schemas.py # Static Pydantic schemas
├── triggers.py # Django-pgtrigger triggers
└── services/
└── services.py # Dependency services
```
### Bazis Models Features
- Every model and mixin must inherit from `bazis.core.models_abstract.InitialBase`
- The logic of missing Meta class in a model has been changed:
- By default in Django, if a model does not define a Meta class, Meta parameters are considered unset
- Bazis adds default inheritance functionality from all parent classes, meaning if the Meta class is not defined, the model will receive a composite Meta class from all parents in the order of model inheritance
### Dynamic Fields
Bazis supports dynamic fields that can be configured at the route level for greater flexibility.
### JSON:API
The framework uses the JSON:API specification, which includes:
- Support for nested structures via `included`
- Multi-level filtering
- Standardized response format
- Relationships between resources
## Development
### Setting Up Development Environment
```bash
# Clone the repository
git clone git@github.com:ecofuture-tech/bazis.git
cd bazis
# Install dependencies
uv sync --dev
# Run tests (from sample directory)
cd sample
pytest ../tests
# Check code
ruff check .
# Format code
ruff format .
```
## Contributing
Contributions are welcome! Here's how you can help:
1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Make your changes
4. Run tests (`cd sample && pytest ../tests`)
5. Commit your changes (`git commit -m 'Add amazing feature'`)
6. Push to the branch (`git push origin feature/amazing-feature`)
7. Open a Pull Request
Please make sure to:
- Write tests for new features
- Update documentation as needed
- Follow the existing code style
- Add your changes to the changelog
## License
Apache License 2.0
See [LICENSE](LICENSE) file for details.
## Links
- [Bazis Documentation](https://github.com/ecofuture-tech/bazis) — main repository
- [Issue Tracker](https://github.com/ecofuture-tech/bazis/issues) — report bugs or request features
- [Bazis Test Utils](https://github.com/ecofuture-tech/bazis-test-utils) — testing utilities
## Support
If you have questions or issues:
- Check the [documentation](https://github.com/ecofuture-tech/bazis)
- Search [existing issues](https://github.com/ecofuture-tech/bazis/issues)
- Create a [new issue](https://github.com/ecofuture-tech/bazis/issues/new) with detailed information
## Ecosystem Packages
Bazis supports extensions through additional packages:
- `bazis-test-utils` — testing utilities
- `bazis-<n>` — other extensions (add `bazis-` prefix to the name)
All extension packages require the `bazis` core package to be installed.
---
Made with ❤️ by the Bazis team
| text/markdown | null | Ilya Kharyn <ilya.tt07@gmail.com> | null | Ilya Kharyn <ilya.tt07@gmail.com> | null | bazis, django, fastapi, pydantic, framework, jsonapi | [
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
... | [] | null | null | >=3.12 | [] | [] | [] | [
"django~=6.0",
"django-admin-autocomplete-filter~=0.7",
"django-clone~=5.3",
"django-pgtrigger>=4.15",
"django-pghistory~=3.1",
"django-sequences~=2.9",
"django-constance>=4.3",
"django-admin-rangefilter~=0.12",
"django-redis~=5.4",
"django-translated-fields~=0.13",
"email-validator>=2.0",
"fa... | [] | [] | [] | [
"Home, https://github.com/ecofuture-tech/bazis"
] | 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-18T09:58:22.348858 | bazis-2.2.4-py3-none-any.whl | 184,964 | a9/24/8da990f3cc44ace5365cdc54f695e4c14c7d89e07400a900bab7d2aa0a41/bazis-2.2.4-py3-none-any.whl | py3 | bdist_wheel | null | false | faf1e71b4b078101f93fea3d1e772792 | 23f7670def42d8d0738b3b4ca43410eb2d640957e5ae019abe8ebb3a5bdba276 | a9248da990f3cc44ace5365cdc54f695e4c14c7d89e07400a900bab7d2aa0a41 | Apache-2.0 | [
"LICENSE",
"NOTICE"
] | 253 |
2.4 | roam-code | 9.1.0 | Instant codebase comprehension for AI coding agents | <div align="center">
# roam
**Instant codebase comprehension for AI coding agents. Semantic graph, algorithm anti-pattern detection, architecture health -- one CLI, zero API keys.**
*56 commands · 22 languages · algorithm catalog · 100% local*
[](https://pypi.org/project/roam-code/)
[](https://github.com/Cranot/roam-code/stargazers)
[](https://github.com/Cranot/roam-code/actions/workflows/roam-ci.yml)
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
</div>
---
## What is Roam?
Roam pre-indexes your codebase into a semantic graph -- symbols, dependencies, call graphs, architecture, and git history -- stored in a local SQLite DB. Agents query it via CLI instead of repeatedly grepping files and guessing structure.
Unlike LSPs (editor-bound and language-specific) or Sourcegraph (hosted search), Roam provides architecture-level graph queries -- offline, cross-language, and compact.
A semantic graph means Roam understands what functions call what, how modules depend on each other, which tests cover which code, the overall architecture structure, and where algorithms can be improved. The built-in algorithm catalog detects 23 anti-patterns (O(n^2) loops, N+1 queries, quadratic string building, branching recursion) and suggests better approaches with Big-O improvements.
```
Codebase ──> [Index] ──> Semantic Graph ──> CLI ──> AI Agent
│ │ │
tree-sitter symbols one call
22 languages + edges replaces
git history + metrics 5-10 tool calls
```
### The problem
Coding agents explore codebases inefficiently: dozens of grep/read cycles, high token cost, no structural understanding. Roam replaces this with one graph query:
```
$ roam context Flask
Callers: 47 Callees: 3
Affected tests: 31
Files to read:
src/flask/app.py:76-963 # definition
src/flask/__init__.py:1-15 # re-export
src/flask/testing.py:22-45 # caller: FlaskClient.__init__
tests/test_basic.py:12-30 # caller: test_app_factory
...12 more files
```
### Core commands
```bash
$ roam understand # full codebase briefing
$ roam context <name> # files-to-read with exact line ranges
$ roam preflight <name> # blast radius + tests + complexity + architecture rules
$ roam health # composite score (0-100)
$ roam diff # blast radius of uncommitted changes
```
## Best for
- **Agent-assisted coding** -- structured answers that reduce token usage vs raw file exploration
- **Large codebases (100+ files)** -- graph queries beat linear search at scale
- **Architecture governance** -- health scores, CI quality gates, dependency cycle detection
- **Safe refactoring** -- blast radius, affected tests, pre-change safety checks
- **Algorithm optimization** -- detect O(n^2) loops, N+1 queries, and 21 other anti-patterns with suggested fixes
- **Multi-repo projects** -- cross-repo API edge detection between frontend and backend
### When NOT to use Roam
- **Real-time type checking** -- use an LSP (pyright, gopls, tsserver). Roam is static and offline.
- **Dynamic / runtime analysis** -- Roam cannot trace reflection, eval, or dynamic dispatch.
- **Small scripts (<10 files)** -- just read the files directly.
- **Pure text search** -- ripgrep is faster for raw string matching.
## Why use Roam
**Speed.** One command replaces 5-10 tool calls (in typical workflows). Under 0.5s for any query.
**Dependency-aware.** Computes structure, not string matches. Knows `Flask` has 47 dependents and 31 affected tests. `grep` knows it appears 847 times.
**LLM-optimized output.** Plain ASCII, compact abbreviations (`fn`, `cls`, `meth`), `--json` envelopes. Designed for agent consumption, not human decoration.
**Fully local.** No API keys, telemetry, or network calls. Works in air-gapped environments.
**Algorithm-aware.** Built-in catalog of 23 anti-patterns. Detects suboptimal algorithms (quadratic loops, N+1 queries, unbounded recursion) and suggests fixes with Big-O improvements and confidence scores.
**CI-ready.** `--json` output, `--gate` quality gates, GitHub Action, SARIF 2.1.0.
| | Without Roam | With Roam |
|--|-------------|-----------|
| Tool calls | 8 | **1** |
| Wall time | ~11s | **<0.5s** |
| Tokens consumed | ~15,000 | **~3,000** |
*Measured on a typical agent workflow in a 200-file Python project (Flask). See [benchmarks](#performance) for more.*
<details>
<summary><strong>Table of Contents</strong></summary>
**Getting Started:** [What is Roam?](#what-is-roam) · [Best for](#best-for) · [Why use Roam](#why-use-roam) · [Install](#install) · [Quick Start](#quick-start)
**Using Roam:** [Commands](#commands) · [Walkthrough](#walkthrough-investigating-a-codebase) · [AI Coding Tools](#integration-with-ai-coding-tools) · [MCP Server](#mcp-server)
**Operations:** [CI/CD Integration](#cicd-integration) · [SARIF Output](#sarif-output) · [For Teams](#for-teams)
**Reference:** [Language Support](#language-support) · [Performance](#performance) · [How It Works](#how-it-works) · [How Roam Compares](#how-roam-compares) · [FAQ](#faq)
**More:** [Limitations](#limitations) · [Troubleshooting](#troubleshooting) · [Update / Uninstall](#update--uninstall) · [Development](#development) · [Contributing](#contributing)
</details>
## Install
```bash
pip install roam-code
# Recommended: isolated environment
pipx install roam-code
# or
uv tool install roam-code
# From source
pip install git+https://github.com/Cranot/roam-code.git
```
Requires Python 3.9+. Works on Linux, macOS, and Windows.
> **Windows:** If `roam` is not found after installing with `uv`, run `uv tool update-shell` and restart your terminal.
## Quick Start
```bash
cd your-project
roam init # indexes codebase, creates config + CI workflow
roam understand # full codebase briefing
```
First index takes ~5s for 200 files, ~15s for 1,000 files. Subsequent runs are incremental and near-instant.
**Next steps:**
- **Set up your AI agent:** `roam describe --write` (auto-detects CLAUDE.md, AGENTS.md, .cursor/rules, etc. — see [integration instructions](#integration-with-ai-coding-tools))
- **Explore:** `roam health` → `roam weather` → `roam map`
- **Add to CI:** `roam init` already generated a GitHub Action
<details>
<summary><strong>Try it on Roam itself</strong></summary>
```bash
git clone https://github.com/Cranot/roam-code.git
cd roam-code
pip install -e .
roam init
roam understand
roam health
```
</details>
## Works With
<p align="center">
<a href="#integration-with-ai-coding-tools">Claude Code</a> •
<a href="#integration-with-ai-coding-tools">Cursor</a> •
<a href="#integration-with-ai-coding-tools">Windsurf</a> •
<a href="#integration-with-ai-coding-tools">GitHub Copilot</a> •
<a href="#integration-with-ai-coding-tools">Aider</a> •
<a href="#integration-with-ai-coding-tools">Cline</a> •
<a href="#integration-with-ai-coding-tools">Gemini CLI</a> •
<a href="#integration-with-ai-coding-tools">OpenAI Codex CLI</a> •
<a href="#mcp-server">MCP</a> •
<a href="#cicd-integration">GitHub Actions</a> •
<a href="#cicd-integration">GitLab CI</a> •
<a href="#cicd-integration">Azure DevOps</a>
</p>
## Commands
The [5 core commands](#core-commands) shown above cover ~80% of agent workflows. 56 commands are organized into 7 categories.
<details>
<summary><strong>Full command reference</strong></summary>
### Getting Started
| Command | Description |
|---------|-------------|
| `roam index [--force] [--verbose]` | Build or rebuild the codebase index |
| `roam init` | Guided onboarding: creates `.roam/fitness.yaml`, CI workflow, runs index, shows health |
| `roam understand` | Full codebase briefing: tech stack, architecture, key abstractions, health, conventions, complexity overview, entry points |
| `roam tour [--write PATH]` | Auto-generated onboarding guide: top symbols, reading order, entry points, language breakdown. `--write` saves to Markdown |
| `roam describe [--write] [--force] [-o PATH] [--agent-prompt]` | Auto-generate project description for AI agents. `--write` auto-detects your agent's config file. `--agent-prompt` returns a compact (<500 token) system prompt |
| `roam map [-n N] [--full] [--budget N]` | Project skeleton: files, languages, entry points, top symbols by PageRank. `--budget` caps output to N tokens |
### Daily Workflow
| Command | Description |
|---------|-------------|
| `roam file <path> [--full] [--changed] [--deps-of PATH]` | File skeleton: all definitions with signatures, cognitive load index, health score |
| `roam symbol <name> [--full]` | Symbol definition + callers + callees + metrics. Supports `file:symbol` disambiguation |
| `roam context <symbol> [--task MODE] [--for-file PATH]` | AI-optimized context: definition + callers + callees + files-to-read with line ranges |
| `roam search <pattern> [--kind KIND]` | Find symbols by name pattern, PageRank-ranked |
| `roam grep <pattern> [-g glob] [-n N]` | Text search annotated with enclosing symbol context |
| `roam deps <path> [--full]` | What a file imports and what imports it |
| `roam trace <source> <target> [-k N]` | Dependency paths with coupling strength and hub detection |
| `roam impact <symbol>` | Blast radius: what breaks if a symbol changes (Personalized PageRank weighted) |
| `roam diff [--staged] [--full] [REV_RANGE]` | Blast radius of uncommitted changes or a commit range |
| `roam pr-risk [REV_RANGE]` | PR risk score (0-100, multiplicative model) + structural spread + suggested reviewers |
| `roam diagnose <symbol> [--depth N]` | Root cause analysis: ranks suspects by z-score normalized risk |
| `roam preflight <symbol\|file>` | Compound pre-change check: blast radius + tests + complexity + coupling + fitness |
| `roam safe-delete <symbol>` | Safe deletion check: SAFE/REVIEW/UNSAFE verdict |
| `roam test-map <name>` | Map a symbol or file to its test coverage |
### Codebase Health
| Command | Description |
|---------|-------------|
| `roam health [--no-framework]` | Composite health score (0-100): weighted geometric mean of tangle ratio, god components, bottlenecks, layer violations. Includes propagation cost and algebraic connectivity |
| `roam complexity [--bumpy-road]` | Per-function cognitive complexity (SonarSource-compatible, triangular nesting penalty) + Halstead metrics (volume, difficulty, effort, bugs) + cyclomatic density |
| `roam math [--task T] [--confidence C]` | Algorithm anti-pattern detection: 23-pattern catalog detects suboptimal algorithms (O(n^2) loops, N+1 queries, quadratic string building, branching recursion, loop-invariant calls) and suggests better approaches with Big-O improvements. Confidence calibration via caller-count and bounded-loop analysis |
| `roam weather [-n N]` | Hotspots ranked by geometric mean of churn x complexity (percentile-normalized) |
| `roam debt` | Hotspot-weighted tech debt prioritization with SQALE remediation cost estimates |
| `roam fitness [--explain]` | Architectural fitness functions from `.roam/fitness.yaml` |
| `roam alerts` | Health degradation trend detection (Mann-Kendall + Sen's slope) |
| `roam snapshot [--tag TAG]` | Persist health metrics snapshot for trend tracking |
| `roam trend` | Health score history with sparkline visualization |
| `roam digest [--brief] [--since TAG]` | Compare current metrics against last snapshot |
### Architecture
| Command | Description |
|---------|-------------|
| `roam clusters [--min-size N]` | Community detection vs directory structure. Modularity Q-score (Newman 2004) + per-cluster conductance |
| `roam layers` | Topological dependency layers + upward violations + Gini balance |
| `roam dead [--all] [--summary] [--clusters]` | Unreferenced exported symbols with safety verdicts + confidence scoring (60-95%) |
| `roam fan [symbol\|file] [-n N] [--no-framework]` | Fan-in/fan-out: most connected symbols or files |
| `roam risk [-n N] [--domain KW] [--explain]` | Domain-weighted risk ranking |
| `roam why <name> [name2 ...]` | Role classification (Hub/Bridge/Core/Leaf), reach, criticality |
| `roam split <file>` | Internal symbol groups with isolation % and extraction suggestions |
| `roam entry-points` | Entry point catalog with protocol classification |
| `roam patterns` | Architectural pattern recognition: Strategy, Factory, Observer, etc. |
| `roam visualize [--format mermaid\|dot] [--focus NAME] [--limit N]` | Generate Mermaid or DOT architecture diagrams. Smart filtering via PageRank, cluster grouping, cycle highlighting |
| `roam safe-zones` | Graph-based containment boundaries |
| `roam coverage-gaps` | Unprotected entry points with no path to gate symbols |
### Exploration
| Command | Description |
|---------|-------------|
| `roam module <path>` | Directory contents: exports, signatures, dependencies, cohesion |
| `roam sketch <dir> [--full]` | Compact structural skeleton of a directory |
| `roam uses <name>` | All consumers: callers, importers, inheritors |
| `roam owner <path>` | Code ownership: who owns a file or directory |
| `roam coupling [-n N] [--set]` | Temporal coupling: file pairs that change together (NPMI + lift) |
| `roam fn-coupling` | Function-level temporal coupling across files |
| `roam bus-factor [--brain-methods]` | Knowledge loss risk per module |
| `roam doc-staleness` | Detect stale docstrings |
| `roam conventions` | Auto-detect naming styles, import preferences. Flags outliers |
| `roam breaking [REV_RANGE]` | Breaking change detection: removed exports, signature changes |
| `roam affected-tests <symbol\|file>` | Trace reverse call graph to test files |
### Reports & CI
| Command | Description |
|---------|-------------|
| `roam report [--list] [--config FILE] [PRESET]` | Compound presets: `first-contact`, `security`, `pre-pr`, `refactor` |
| `roam describe --write` | Generate agent config (auto-detects: CLAUDE.md, AGENTS.md, .cursor/rules, etc.) |
### Multi-Repo Workspace
| Command | Description |
|---------|-------------|
| `roam ws init <repo1> <repo2> [--name NAME]` | Initialize a workspace from sibling repos. Auto-detects frontend/backend roles |
| `roam ws status` | Show workspace repos, index ages, cross-repo edge count |
| `roam ws resolve` | Scan for REST API endpoints and match frontend calls to backend routes |
| `roam ws understand` | Unified workspace overview: per-repo stats + cross-repo connections |
| `roam ws health` | Workspace-wide health report with cross-repo coupling assessment |
| `roam ws context <symbol>` | Cross-repo augmented context: find a symbol across repos + show API callers |
| `roam ws trace <source> <target>` | Trace cross-repo paths via API edges |
### Global Options
| Option | Description |
|--------|-------------|
| `roam --json <command>` | Structured JSON output with consistent envelope |
| `roam --compact <command>` | Token-efficient output: TSV tables, minimal JSON envelope |
| `roam <command> --gate EXPR` | CI quality gate (e.g., `--gate score>=70`). Exit code 1 on failure |
</details>
## Walkthrough: Investigating a Codebase
<details>
<summary><strong>10-step walkthrough using Flask as an example</strong> (click to expand)</summary>
Here's how you'd use Roam to understand a project you've never seen before. Using Flask as an example:
**Step 1: Onboard and get the full picture**
```
$ roam init
Created .roam/fitness.yaml (6 starter rules)
Created .github/workflows/roam.yml
Done. 226 files, 1132 symbols, 233 edges.
Health: 78/100
$ roam understand
Tech stack: Python (flask, jinja2, werkzeug)
Architecture: Monolithic — 3 layers, 5 clusters
Key abstractions: Flask, Blueprint, Request, Response
Health: 78/100 — 1 god component (Flask)
Entry points: src/flask/__init__.py, src/flask/cli.py
Conventions: snake_case functions, PascalCase classes, relative imports
Complexity: avg 4.2, 3 high (>15), 0 critical (>25)
```
**Step 2: Drill into a key file**
```
$ roam file src/flask/app.py
src/flask/app.py (python, 963 lines)
cls Flask(App) :76-963
meth __init__(self, import_name, ...) :152
meth route(self, rule, **options) :411
meth register_blueprint(self, blueprint, ...) :580
meth make_response(self, rv) :742
...12 more methods
```
**Step 3: Who depends on this?**
```
$ roam deps src/flask/app.py
Imported by:
file symbols
-------------------------- -------
src/flask/__init__.py 3
src/flask/testing.py 2
tests/test_basic.py 1
...18 files total
```
**Step 4: Find the hotspots**
```
$ roam weather
=== Hotspots (churn x complexity) ===
Score Churn Complexity Path Lang
----- ----- ---------- ---------------------- ------
18420 460 40.0 src/flask/app.py python
12180 348 35.0 src/flask/blueprints.py python
```
**Step 5: Check architecture health**
```
$ roam health
Health: 78/100
Tangle: 0.0% (0/1132 symbols in cycles)
1 god component (Flask, degree 47, actionable)
0 bottlenecks, 0 layer violations
=== God Components (degree > 20) ===
Sev Name Kind Degree Cat File
------- ----- ---- ------ --- ------------------
WARNING Flask cls 47 act src/flask/app.py
```
**Step 6: Get AI-ready context for a symbol**
```
$ roam context Flask
Files to read:
src/flask/app.py:76-963 # definition
src/flask/__init__.py:1-15 # re-export
src/flask/testing.py:22-45 # caller: FlaskClient.__init__
tests/test_basic.py:12-30 # caller: test_app_factory
...12 more files
Callers: 47 Callees: 3
```
**Step 7: Pre-change safety check**
```
$ roam preflight Flask
=== Preflight: Flask ===
Blast radius: 47 callers, 89 transitive
Affected tests: 31 (DIRECT: 12, TRANSITIVE: 19)
Complexity: cc=40 (critical), nesting=6
Coupling: 3 hidden co-change partners
Fitness: 1 violation (max-complexity exceeded)
Verdict: HIGH RISK — consider splitting before modifying
```
**Step 8: Decompose a large file**
```
$ roam split src/flask/app.py
=== Split analysis: src/flask/app.py ===
87 symbols, 42 internal edges, 95 external edges
Cross-group coupling: 18%
Group 1 (routing) — 12 symbols, isolation: 83% [extractable]
meth route L411 PR=0.0088
meth add_url_rule L450 PR=0.0045
...
=== Extraction Suggestions ===
Extract 'routing' group: route, add_url_rule, endpoint (+9 more)
83% isolated, only 3 edges to other groups
```
**Step 9: Understand why a symbol matters**
```
$ roam why Flask url_for Blueprint
Symbol Role Fan Reach Risk Verdict
--------- ------------ ---------- -------- -------- --------------------------------------------------
Flask Hub fan-in:47 reach:89 CRITICAL God symbol (47 in, 12 out). Consider splitting.
url_for Core utility fan-in:31 reach:45 HIGH Widely used utility (31 callers). Stable interface.
Blueprint Bridge fan-in:18 reach:34 moderate Coupling point between clusters.
```
**Step 10: Generate docs and set up CI**
```
$ roam describe --write
Wrote CLAUDE.md (98 lines) # auto-detects: CLAUDE.md, AGENTS.md, .cursor/rules, etc.
$ roam health --gate score>=70
Health: 78/100 — PASS
```
Ten commands. Complete picture: structure, dependencies, hotspots, health, context, safety checks, decomposition, and CI gates.
</details>
## Integration with AI Coding Tools
Roam is designed to be called by coding agents via shell commands. Instead of repeatedly grepping and reading files, the agent runs one `roam` command and gets structured output.
**Decision order for agents:**
| Situation | Command |
|-----------|---------|
| First time in a repo | `roam understand` then `roam tour` |
| Need to modify a symbol | `roam preflight <name>` (blast radius + tests + fitness) |
| Debugging a failure | `roam diagnose <name>` (root cause ranking) |
| Need files to read | `roam context <name>` (files + line ranges) |
| Need to find a symbol | `roam search <pattern>` |
| Need file structure | `roam file <path>` |
| Pre-PR check | `roam pr-risk HEAD~3..HEAD` |
| What breaks if I change X? | `roam impact <symbol>` |
**Fastest setup:**
```bash
roam describe --write # auto-detects your agent's config file
roam describe --write -o AGENTS.md # or specify an explicit path
roam describe --agent-prompt # compact ~500-token prompt (append to any config)
```
<details>
<summary><strong>Copy-paste agent instructions</strong></summary>
```markdown
## Codebase navigation
This project uses `roam` for codebase comprehension. Always prefer roam over Glob/Grep/Read exploration.
Before modifying any code:
1. First time in the repo: `roam understand` then `roam tour`
2. Find a symbol: `roam search <pattern>`
3. Before changing a symbol: `roam preflight <name>` (blast radius + tests + fitness)
4. Need files to read: `roam context <name>` (files + line ranges, prioritized)
5. Debugging a failure: `roam diagnose <name>` (root cause ranking)
6. After making changes: `roam diff` (blast radius of uncommitted changes)
Additional: `roam health` (0-100 score), `roam impact <name>` (what breaks),
`roam pr-risk` (PR risk), `roam file <path>` (file skeleton).
Run `roam --help` for all commands. Use `roam --json <cmd>` for structured output.
```
</details>
<details>
<summary><strong>Where to put this for each tool</strong></summary>
| Tool | Config file |
|------|-------------|
| **Claude Code** | `CLAUDE.md` in your project root |
| **OpenAI Codex CLI** | `AGENTS.md` in your project root |
| **Gemini CLI** | `GEMINI.md` in your project root |
| **Cursor** | `.cursor/rules/roam.mdc` (add `alwaysApply: true` frontmatter) |
| **Windsurf** | `.windsurf/rules/roam.md` (add `trigger: always_on` frontmatter) |
| **GitHub Copilot** | `.github/copilot-instructions.md` |
| **Aider** | `CONVENTIONS.md` |
| **Continue.dev** | `config.yaml` rules |
| **Cline** | `.clinerules/` directory |
</details>
<details>
<summary><strong>Roam vs native tools</strong></summary>
| Task | Use Roam | Use native tools |
|------|----------|-----------------|
| "What calls this function?" | `roam symbol <name>` | LSP / Grep |
| "What files do I need to read?" | `roam context <name>` | Manual tracing (5+ calls) |
| "Is it safe to change X?" | `roam preflight <name>` | Multiple manual checks |
| "Show me this file's structure" | `roam file <path>` | Read the file directly |
| "Understand project architecture" | `roam understand` | Manual exploration |
| "What breaks if I change X?" | `roam impact <symbol>` | No direct equivalent |
| "What tests to run?" | `roam affected-tests <name>` | Grep for imports (misses indirect) |
| "What's causing this bug?" | `roam diagnose <name>` | Manual call-chain tracing |
| "Codebase health score for CI" | `roam health --gate score>=70` | No equivalent |
</details>
## MCP Server
Roam includes a [Model Context Protocol](https://modelcontextprotocol.io/) server for direct integration with tools that support MCP.
```bash
pip install fastmcp
fastmcp run roam.mcp_server:mcp
```
20 read-only tools and 2 resources. All tools query the index -- they never modify your code.
<details>
<summary><strong>MCP tool list</strong></summary>
| Tool | Description |
|------|-------------|
| `understand` | Full codebase briefing |
| `health` | Health score (0-100) + issues |
| `preflight` | Pre-change safety check |
| `search_symbol` | Find symbols by name |
| `context` | Files-to-read for modifying a symbol |
| `trace` | Dependency path between two symbols |
| `impact` | Blast radius of changing a symbol |
| `file_info` | File skeleton with all definitions |
| `pr_risk` | Risk score for pending changes |
| `breaking_changes` | Detect breaking changes between refs |
| `affected_tests` | Find tests affected by a change |
| `dead_code` | List unreferenced exports |
| `complexity_report` | Per-symbol cognitive complexity |
| `repo_map` | Project skeleton with key symbols |
| `tour` | Auto-generated onboarding guide |
| `diagnose` | Root cause analysis for debugging |
| `visualize` | Generate Mermaid or DOT architecture diagrams |
| `math` | Algorithm anti-pattern detection with confidence calibration |
| `ws_understand` | Unified multi-repo workspace overview |
| `ws_context` | Cross-repo augmented symbol context |
**Resources:** `roam://health` (current health score), `roam://summary` (project overview)
</details>
<details>
<summary><strong>Claude Code</strong></summary>
```bash
claude mcp add roam -- fastmcp run roam.mcp_server:mcp
```
Or add to `.mcp.json` in your project root:
```json
{
"mcpServers": {
"roam": {
"command": "fastmcp",
"args": ["run", "roam.mcp_server:mcp"]
}
}
}
```
</details>
<details>
<summary><strong>Claude Desktop</strong></summary>
Add to your `claude_desktop_config.json`:
```json
{
"mcpServers": {
"roam": {
"command": "fastmcp",
"args": ["run", "roam.mcp_server:mcp"],
"cwd": "/path/to/your/project"
}
}
}
```
</details>
<details>
<summary><strong>Cursor</strong></summary>
Add to `.cursor/mcp.json`:
```json
{
"mcpServers": {
"roam": {
"command": "fastmcp",
"args": ["run", "roam.mcp_server:mcp"]
}
}
}
```
</details>
<details>
<summary><strong>VS Code + Copilot</strong></summary>
Add to `.vscode/mcp.json`:
```json
{
"servers": {
"roam": {
"type": "stdio",
"command": "fastmcp",
"args": ["run", "roam.mcp_server:mcp"]
}
}
}
```
</details>
## CI/CD Integration
All you need is Python 3.9+ and `pip install roam-code`.
### GitHub Actions
```yaml
# .github/workflows/roam.yml
name: Roam Analysis
on: [pull_request]
jobs:
roam:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: Cranot/roam-code@main
with:
command: health --gate score>=70
comment: true
fail-on-violation: true
```
Use `roam init` to auto-generate this workflow.
| Input | Default | Description |
|-------|---------|-------------|
| `command` | `health` | Roam command to run |
| `python-version` | `3.12` | Python version |
| `comment` | `false` | Post results as PR comment |
| `fail-on-violation` | `false` | Fail the job on violations |
| `roam-version` | (latest) | Pin to a specific version |
<details>
<summary><strong>GitLab CI</strong></summary>
```yaml
roam-analysis:
stage: test
image: python:3.12-slim
before_script:
- pip install roam-code
script:
- roam index
- roam health --gate score>=70
- roam --json pr-risk origin/main..HEAD > roam-report.json
artifacts:
paths:
- roam-report.json
rules:
- if: $CI_MERGE_REQUEST_IID
```
</details>
<details>
<summary><strong>Azure DevOps / any CI</strong></summary>
Universal pattern:
```bash
pip install roam-code
roam index
roam health --gate score>=70 # exit 1 on failure
roam --json health > report.json
```
</details>
## SARIF Output
Roam exports analysis results in [SARIF 2.1.0](https://sarifweb.azurewebsites.net/) format for GitHub Code Scanning.
```python
from roam.output.sarif import health_to_sarif, write_sarif
sarif = health_to_sarif(health_data)
write_sarif(sarif, "roam-health.sarif")
```
```yaml
- uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: roam-health.sarif
```
## For Teams
Zero infrastructure, zero vendor lock-in, zero data leaving your network.
| Tool | Annual cost (20-dev team) | Infrastructure | Setup time |
|------|--------------------------|----------------|------------|
| SonarQube Server | $15,000-$45,000 | Self-hosted server | Days |
| CodeScene | $20,000-$60,000 | SaaS or on-prem | Hours |
| Code Climate | $12,000-$36,000 | SaaS | Hours |
| **Roam** | **$0 (MIT license)** | **None (local)** | **5 minutes** |
<details>
<summary><strong>Team rollout guide</strong></summary>
**Week 1-2 (pilot):** 1-2 developers run `roam init` on one repo. Use `roam preflight` before changes, `roam pr-risk` before PRs.
**Week 3-4 (expand):** Add `roam health --gate score>=60` to CI as a non-blocking check.
**Month 2+ (standardize):** Tighten to `--gate score>=70`. Expand to additional repos. Track trajectory with `roam trend`.
</details>
<details>
<summary><strong>Complements your existing stack</strong></summary>
| If you use... | Roam adds... |
|---------------|-------------|
| **SonarQube** | Architecture-level analysis: dependency cycles, god components, blast radius, health scoring |
| **CodeScene** | Free, local alternative for health scoring and hotspot analysis |
| **ESLint / Pylint** | Cross-language architecture checks. Linters enforce style per file; Roam enforces architecture across the codebase |
| **LSP** | AI-agent-optimized queries. `roam context` answers "what calls this?" with PageRank-ranked results in one call |
</details>
## Language Support
### Tier 1 -- Full extraction (dedicated parsers)
| Language | Extensions | Symbols | References | Inheritance |
|----------|-----------|---------|------------|-------------|
| Python | `.py` `.pyi` | classes, functions, methods, decorators, variables | imports, calls, inheritance | extends, `__all__` exports |
| JavaScript | `.js` `.jsx` `.mjs` `.cjs` | classes, functions, arrow functions, CJS exports | imports, require(), calls | extends |
| TypeScript | `.ts` `.tsx` `.mts` `.cts` | interfaces, type aliases, enums + all JS | imports, calls, type refs | extends, implements |
| Java | `.java` | classes, interfaces, enums, constructors, fields | imports, calls | extends, implements |
| Go | `.go` | structs, interfaces, functions, methods, fields | imports, calls | embedded structs |
| Rust | `.rs` | structs, traits, impls, enums, functions | use, calls | impl Trait for Struct |
| C / C++ | `.c` `.h` `.cpp` `.hpp` `.cc` | structs, classes, functions, namespaces, templates | includes, calls | extends |
| C# | `.cs` | classes, interfaces, structs, enums, records, methods, constructors, properties, delegates, events, fields | using directives, calls, `new`, attributes | extends, implements |
| PHP | `.php` | classes, interfaces, traits, enums, methods, properties | namespace use, calls, static calls, `new` | extends, implements, use (traits) |
| Visual FoxPro | `.prg` | functions, procedures, classes, methods, properties, constants | DO, SET PROCEDURE/CLASSLIB, CREATEOBJECT, `=func()`, `obj.method()` | DEFINE CLASS ... AS |
| Vue | `.vue` | via `<script>` block extraction (TS/JS) | imports, calls, type refs | extends, implements |
| Svelte | `.svelte` | via `<script>` block extraction (TS/JS) | imports, calls, type refs | extends, implements |
<details>
<summary><strong>Salesforce ecosystem (Tier 1)</strong></summary>
| Language | Extensions | Symbols | References |
|----------|-----------|---------|------------|
| Apex | `.cls` `.trigger` | classes, triggers, SOQL, annotations | imports, calls, System.Label, generic type refs |
| Aura | `.cmp` `.app` `.evt` `.intf` `.design` | components, attributes, methods, events | controller refs, component refs |
| LWC (JavaScript) | `.js` (in LWC dirs) | anonymous class from filename | `@salesforce/apex/`, `@salesforce/schema/`, `@salesforce/label/` |
| Visualforce | `.page` `.component` | pages, components | controller/extensions, merge fields, includes |
| SF Metadata XML | `*-meta.xml` | objects, fields, rules, layouts | Apex class refs, formula field refs, Flow actionCalls |
Cross-language edges mean `roam impact AccountService` shows blast radius across Apex, LWC, Aura, Visualforce, and Flows.
</details>
### Tier 2 -- Generic extraction
Ruby (`.rb`), Kotlin (`.kt` `.kts`), Swift (`.swift`), Scala (`.scala` `.sc`)
Tier 2 languages get symbol extraction and basic inheritance via a generic tree-sitter walker.
## Performance
| Metric | Value |
|--------|-------|
| Index 200 files | ~3-5s |
| Index 3,000 files | ~2 min |
| Incremental (no changes) | <1s |
| Any query command | <0.5s |
<details>
<summary><strong>Detailed benchmarks</strong></summary>
### Indexing Speed
| Project | Language | Files | Symbols | Edges | Index Time | Rate |
|---------|----------|-------|---------|-------|-----------|------|
| Express | JS | 211 | 624 | 804 | 3s | 70 files/s |
| Axios | JS | 237 | 1,065 | 868 | 6s | 41 files/s |
| Vue | TS | 697 | 5,335 | 8,984 | 25s | 28 files/s |
| Laravel | PHP | 3,058 | 39,097 | 38,045 | 1m46s | 29 files/s |
| Svelte | TS | 8,445 | 16,445 | 19,618 | 2m40s | 52 files/s |
### Quality Benchmark
| Repo | Language | Score | Coverage | Edge Density | Commands |
|------|----------|-------|----------|--------------|----------|
| Laravel | PHP | **9.55** | 91.2% | 0.97 | 29/29 |
| Vue | TS | **9.27** | 85.8% | 1.68 | 29/29 |
| Svelte | TS | **9.04** | 94.7% | 1.19 | 29/29 |
| Axios | JS | **8.98** | 85.9% | 0.82 | 29/29 |
| Express | JS | **8.46** | 96.0% | 1.29 | 29/29 |
### Token Efficiency
| Metric | Value |
|--------|-------|
| 1,600-line file → `roam file` | ~5,000 chars (~70:1 compression) |
| Full project map | ~4,000 chars |
| `--compact` mode | 40-50% additional token reduction |
| `roam preflight` replaces | 5-7 separate agent tool calls |
</details>
## How It Works
```
Codebase
|
[1] Discovery ──── git ls-files (respects .gitignore)
|
[2] Parse ──────── tree-sitter AST per file (22 languages)
|
[3] Extract ────── symbols + references (calls, imports, inheritance)
|
[4] Resolve ────── match references to definitions → edges
|
[5] Metrics ────── adaptive PageRank, betweenness, cognitive complexity, Halstead
|
[6] Algorithms ── 23-pattern anti-pattern catalog (O(n^2) loops, N+1, recursion)
|
[7] Git ────────── churn, co-change matrix, authorship, Renyi entropy
|
[8] Clusters ───── Louvain community detection
|
[9] Health ─────── per-file scores (7-factor) + composite score (0-100)
|
[10] Store ─────── .roam/index.db (SQLite, WAL mode)
```
After the first full index, `roam index` only re-processes changed files (mtime + SHA-256 hash). Incremental updates are near-instant.
<details>
<summary><strong>Graph algorithms</strong></summary>
- **Adaptive PageRank** -- damping factor auto-tunes based on cycle density (0.82-0.92); identifies the most important symbols (used by `map`, `search`, `context`)
- **Personalized PageRank** -- distance-weighted blast radius for `impact` (Gleich, 2015)
- **Adaptive betweenness centrality** -- exact for small graphs, sqrt-scaled sampling for large (Brandes & Pich, 2007); finds bottleneck symbols
- **Edge betweenness centrality** -- identifies critical cycle-breaking edges in SCCs (Brandes, 2001)
- **Tarjan's SCC** -- detects dependency cycles with tangle ratio
- **Propagation Cost** -- fraction of system affected by any change, via transitive closure (MacCormack, Rusnak & Baldwin, 2006)
- **Algebraic connectivity (Fiedler value)** -- second-smallest Laplacian eigenvalue; measures architectural robustness (Fiedler, 1973)
- **Louvain community detection** -- groups related symbols into clusters
- **Modularity Q-score** -- measures if cluster boundaries match natural community structure (Newman, 2004)
- **Conductance** -- per-cluster boundary tightness: cut(S, S_bar) / min(vol(S), vol(S_bar)) (Yang & Leskovec)
- **Topological sort** -- computes dependency layers, Gini coefficient for layer balance (Gini, 1912), weighted violation severity
- **k-shortest simple paths** -- traces dependency paths with coupling strength
- **Renyi entropy (order 2)** -- measures co-change distribution; more robust to outliers than Shannon (Renyi, 1961)
- **Mann-Kendall trend test** -- non-parametric degradation detection, robust to noise (Mann, 1945; Kendall, 1975)
- **Sen's slope estimator** -- robust trend magnitude, resistant to outliers (Sen, 1968)
- **NPMI** -- Normalized Pointwise Mutual Information for coupling strength (Bouma, 2009)
- **Lift** -- association rule mining metric for co-change statistical significance (Agrawal & Srikant, 1994)
- **Halstead metrics** -- volume, difficulty, effort, and predicted bugs from operator/operand counts (Halstead, 1977)
- **SQALE remediation cost** -- time-to-fix estimates per issue type for tech debt prioritization (Letouzey, 2012)
- **Algorithm anti-pattern catalog** -- 23 patterns detecting suboptimal algorithms (quadratic loops, N+1 queries, quadratic string building, branching recursion, manual top-k, loop-invariant calls) with confidence calibration via caller-count and bounded-loop analysis
</details>
<details>
<summary><strong>Health scoring</strong></summary>
Composite health score (0-100) using a **weighted geometric mean** of sigmoid health factors. Non-compensatory: a zero in any dimension cannot be masked by high scores in others.
| Factor | Weight | What it measures |
|--------|--------|-----------------|
| Tangle ratio | 30% | % of symbols in dependency cycles |
| God components | 20% | Symbols with extreme fan-in/fan-out |
| Bottlenecks | 15% | High-betweenness chokepoints |
| Layer violations | 15% | Upward dependency violations (severity-weighted by layer distance) |
| Per-file health | 20% | Average of 7-factor file health scores |
Each factor uses sigmoid health: `h = e^(-signal/scale)` (1 = pristine, approaches 0 = worst). Score = `100 * product(h_i ^ w_i)`. Also reports **propagation cost** (MacCormack 2006) and **algebraic connectivity** (Fiedler 1973). Per-file health (1-10) combines: cognitive complexity (triangular nesting penalty per Sweller's Cognitive Load Theory), indentation complexity, cycle membership, god component membership, dead export ratio, co-change entropy, and churn amplification.
</details>
## How Roam Compares
Roam is **not** a replacement for your linter, LSP, or SonarQube. It fills a different gap: giving AI agents structural understanding of the codebase in a format optimized for LLM consumption.
| Tool | What it does | How Roam differs |
|------|-------------|------------------|
| **ctags / cscope** | Symbol index for editors | Roam adds graph metrics, git signals, architecture analysis, and AI-optimized output |
| **LSP (pyright, gopls)** | Real-time type checking | LSP requires a running server and file:line:col queries. Roam is offline, exploratory, and cross-language |
| **Sourcegraph** | Code search + AI | Requires hosted deployment. Roam is local-only, MIT-licensed |
| **Aider repo map** | Tree-sitter + PageRank | Context selection for chat. Roam adds git signals, 50+ architecture commands, CI gates |
| **CodeScene** | Behavioral code analysis | Commercial SaaS. Roam is free, local, uses peer-reviewed algorithms (Mann-Kendall, NPMI, Personalized PageRank) |
| **SonarQube** | Code quality + security | Heavy server. Roam's cognitive complexity follows SonarSource spec |
| **grep / ripgrep** | Text search | No semantic understanding. Can't distinguish definitions from usage |
## FAQ
**Does Roam send any data externally?**
No. Zero network calls. No telemetry, no analytics, no update checks.
**Can Roam run in air-gapped environments?**
Yes. Once installed, no internet access is required.
**Does Roam modify my source code?**
No. R | text/markdown | CosmoHac | null | null | null | null | codebase, code-analysis, tree-sitter, ai-tools, cli, static-analysis | [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Pr... | [] | null | null | >=3.9 | [] | [] | [] | [
"click>=8.0",
"tree-sitter>=0.23",
"tree-sitter-language-pack>=0.6",
"networkx>=3.0",
"pytest>=7.0; extra == \"dev\"",
"ruff>=0.4; extra == \"dev\""
] | [] | [] | [] | [
"Homepage, https://github.com/Cranot/roam-code",
"Repository, https://github.com/Cranot/roam-code",
"Issues, https://github.com/Cranot/roam-code/issues"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T09:57:57.814033 | roam_code-9.1.0.tar.gz | 527,280 | 1f/a0/da42408c61c7019c0324d46d98c2446af264b7d327e2a2ea6004c9c35417/roam_code-9.1.0.tar.gz | source | sdist | null | false | ad0b43d2a21deb3031ab5f3ebdb1c3ab | 5c198936103d2900250fe850736780772cedd48e8efaf1aff2dc6f3c91270d82 | 1fa0da42408c61c7019c0324d46d98c2446af264b7d327e2a2ea6004c9c35417 | MIT | [
"LICENSE"
] | 562 |
2.4 | fluidpatcher | 1.0.2 | FluidSynth patch manager and performance toolkit | # FluidPatcher
* [Source Code](https://github.com/GeekFunkLabs/fluidpatcher)
* [Official Documentation](https://geekfunklabs.github.io/fluidpatcher)
FluidPatcher is a lightweight Python toolkit for building playable
FluidSynth-based instruments driven by MIDI events. It provides:
* A simple user-facing API for building applications/front-ends
* Rich YAML-based bank/patch file format for defining synth setups
* Support for multiple soundfonts, layered MIDI routing, and rules
* Built-in players (arpeggiators, sequencers, MIDI files, loopers)
* Optional LADSPA audio effects
FluidPatcher is designed for small systems such as Raspberry Pi but runs
anywhere FluidSynth does.
## Installation
### System Requirements
* Python 3.10+
* PyYAML
* [FluidSynth](
https://github.com/FluidSynth/fluidsynth/wiki/Download
) 2.2.0+
### Install FluidPatcher
```bash
pip install fluidpatcher
```
Or install from source:
```bash
git clone https://github.com/GeekFunkLabs/fluidpatcher.git
cd fluidpatcher
pip install -e .
```
## Configuration
FluidPatcher looks for config at `FLUIDPATCHER_CONFIG` if defined, or
`~/.config/fluidpatcher/fluidpatcherconf.yaml`. A default config is
created if not found. The config file can be used to store/specify:
* Paths for soundfonts, bank files, MIDI files, LADSPA effects
* FluidSynth [settings](
https://www.fluidsynth.org/api/fluidsettings.xml
)
e.g. audio driver/device if other than default
* State information for specific programs
## API Overview/Quick Start
```python
import fluidpatcher
fp = fluidpatcher.FluidPatcher()
fp.load_bank("mybank.yaml")
fp.apply_patch("Piano")
```
Play notes on an attached MIDI controller to hear patches. By default,
FluidSynth will automatically connect to MIDI devices.
Sample programs are in `examples/`, and can be run with
```bash
python -m fluidpatcher.examples.<example_name>
```
## Banks & Patches
Users access all of FluidPatcher's features primarily by writing bank
files. Bank files are a declarative, YAML-based format for describing
synth *patches*. The underlying engine parses bank files and pre-loads
required soundfonts so that different patches can be applied quickly in
live performance.
View the Tutorials section in the docs and/or example banks
(`data/banks/tutorial/`) for guided learning.
## Status & Contributions
FluidPatcher is under active development. The goal is to keep the API
minimalist and general, with most features/functionality implemented in
bank files or external programs. Contributions, bug reports, and example
banks are welcome.
Please open issues or pull requests on GitHub.
## License
MIT. See LICENSE for details.
FluidPatcher uses the FluidSynth library (LGPL-2.1) via dynamic linking.
| text/markdown | null | Bill Peterson <bill@geekfunklabs.com> | null | null | MIT License
Copyright (c) 2021 Bill Peterson
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
| null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"PyYAML>=6.0"
] | [] | [] | [] | [
"Homepage, https://github.com/GeekFunkLabs/fluidpatcher",
"Documentation, https://geekfunklabs.github.io/fluidpatcher/",
"Source, https://github.com/GeekFunkLabs/fluidpatcher"
] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T09:57:01.600370 | fluidpatcher-1.0.2.tar.gz | 316,178 | 16/cb/c6c7c89ca95589539aa6f6253ba15fa5162db64b58cf362ffb6124d1957b/fluidpatcher-1.0.2.tar.gz | source | sdist | null | false | bbd9471783f84f75dc484df854bd666a | 73594e5ef68970c5f1dff758747338804a99d377abd976c78cfc12cf6ed06c12 | 16cbc6c7c89ca95589539aa6f6253ba15fa5162db64b58cf362ffb6124d1957b | null | [
"LICENSE"
] | 249 |
2.4 | open-taranis | 0.2.4 | Python framework for AI agents logic-only coding with streaming, tool calls, and multi-LLM provider support | # open-taranis
Python framework for AI agents logic-only coding with streaming, tool calls, and multi-LLM provider support.
Only the **"fairly stable"** versions are published on PyPi, but to get the latest experimental versions, clone this repository and install it !
## Installation
```bash
pip install open-taranis --upgrade
```
For package on **PyPi**
**or**
```bash
git clone https://github.com/SyntaxError4Life/open-taranis && cd open-taranis/ && pip install .
```
For last version
## Quick Start
<details><summary><b>Simplest</b></summary>
```python
import open_taranis as T
client = T.clients.openrouter() # API_KEY in env_var
messages = [
T.create_user_prompt("Tell me about yourself")
]
stream = T.clients.openrouter_request(
client=client,
messages=messages,
model="nvidia/nemotron-3-nano-30b-a3b:free",
)
print("assistant : ",end="")
for token, tool, tool_bool in T.handle_streaming(stream) :
if token :
print(token, end="")
```
</details>
<details><summary><b>Make a simple agent with a context windows on the 6 last turns</b></summary>
```python
import open_taranis as T
class Agent(T.agent_base):
def __init__(self):
super().__init__()
self.client = T.clients.openrouter()
self._system_prompt = [T.create_system_prompt(
"You're an agent nammed **Taranis** !"
)]
def create_stream(self):
return T.clients.openrouter_request(
client=self.client,
messages=self._system_prompt+self.messages,
model="nvidia/nemotron-3-nano-30b-a3b:free"
)
def manage_messages(self):
self.messages = self.messages[-12:] # Each turn have 1 user and 1 assistant
My_agent = Agent()
while True :
prompt = input("user : ")
print("\n\nagent : ", end="")
for t in My_agent(prompt):
print(t, end="", flush=True)
print("\n\n","="*60,"\n")
```
</details>
<details><summary><b>To create a simple display using gradio as backend</b></summary>
```python
import open_taranis as T
import open_taranis.web_front as W
import gradio as gr
class Gradio_agent(T.agent_base):
def __init__(self):
super().__init__()
self._system_prompt = [T.create_system_prompt("You are a agent nammed **Taranis**")]
def create_stream(self):
return T.clients.openrouter_request(
client=T.clients.openrouter(),
messages=self._system_prompt+self.messages,
model="nvidia/nemotron-3-nano-30b-a3b:free"
)
gr.ChatInterface(
fn=W.create_fn_gradio(Gradio_agent()),
title="Open-taranis Agent"
).launch()
```
</details>
---
## Use the commands :
- `taranis help` : in the name...
- `taranis update` : upgrade the framework
- `taranis open` : open the TUI
### The TUI :
- `/help` to start
## Documentation :
- [Base of the docs](https://zanomega.com/open-taranis/)
Available in [French](https://zanomega.com/open-taranis/fr/)
## Roadmap
- [X] v0.0.1: start
- [X] v0.0.x: Add and confirm other API providers (in the cloud, not locally)
- [X] v0.1.x: Functionality verifications in [examples](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/)
- [X] v0.2.x: Add features for **logic-only coding** approach, start with `agent_base`
- [ ] v0.3.x: Add a full agent in **TUI** and upgrade web client **deployments**
- The rest will follow soon.
## Changelog
<details><summary> <b>v0.0.x : The start</b> </summary>
- **v0.0.4** : Add **xai** and **groq** provider
- **v0.0.6** : Add **huggingface** provider and args for **clients.veniceai_request**
</details>
<details><summary><b>v0.1.x : Gradio, commands and TUI</b></summary>
- **v0.1.0** : Start the **docs**, add **update-checker** and preparing for the continuation of the project...
- **v0.1.1** : Code to deploy a **frontend with gradio** added (no complex logic at the moment, ex: tool_calls)
- **v0.1.2** : Fixed a display bug in the **web_front** and experimentally added **ollama as a backend**
- **v0.1.3** : Fixed the memory reset in the **web_front** and remove **ollama module** for **openai front** (work 100 times better)
- **v0.1.4** : Fixed `web_front` for native use on huggingface, as well as `handle_streaming` which had tool retrieval issues
- **v0.1.7** : Added a **TUI** and **commands**, detection of **env variables** (API keys) and tools in the framework
</details>
<details><summary><b>v0.2.x : Agents</b></summary>
- **v0.2.0** : Adding `agent_base`
- **v0.2.1** : Updated `agent_base` and added a more concrete example of agents
- **v0.2.2** : Upgraded all the code to add [**Kimi Code**](https://www.kimi.com/code) as client and reduce code (**Not official !**)
- **v0.2.3** : Updated `agent_base`, add some functions and add a **cool** agent
- **v0.2.4** : Improved CoT techniques and updated `web_front.py`, deploy an agent to the browser in a few lines
</details>
## Advanced Examples
- [tools call in a JSON database](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/test_json_database.py)
- [tools call in a HR JSON database in multi-rounds](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/test_HR_json_database.py)
- [simple search agent with Brave API](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/brave_research.py)
- [full auto search agent with Brave API](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/brave_research_loop.py)
- [agent with compressible memory (recommended with Kimi)](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/infinite_agent_v1.py)
## Links
- [PyPI](https://pypi.org/project/open-taranis/)
- [GitHub Repository](https://github.com/SyntaxError4Life/open-taranis) | text/markdown | null | SyntaxError4Life <contact@zanomega.com> | null | null | GPL-3.0-or-later | API, LLM | [
"License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
"Programming Language :: Python :: 3"
] | [] | null | null | >=3.8 | [] | [] | [] | [
"bs4",
"openai",
"packaging",
"requests"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.12.12 | 2026-02-18T09:56:58.784461 | open_taranis-0.2.4.tar.gz | 39,696 | e6/ac/fb48c794026724f464bd3d6ec335eb3375e39779356ed4ce04a6496c26d0/open_taranis-0.2.4.tar.gz | source | sdist | null | false | fb446f7b0c54bb3e1e55cac78da318a2 | 143bef0388d14e29cb836ff7a227a58f61bd2789c5e37db50d2f29b64188caea | e6acfb48c794026724f464bd3d6ec335eb3375e39779356ed4ce04a6496c26d0 | null | [
"LICENSE"
] | 264 |
2.4 | causaliq-core | 0.4.0 | Core utilities and classes for the CausalIQ ecosystem | # causaliq-core
[](https://opensource.org/licenses/MIT)
This is the core package providing common functionality required by several CausalIQ packages. It is part of the [CausalIQ ecosystem](https://causaliq.org) for intelligent causal discovery and inference.
## Installation
Install from PyPI:
```bash
pip install causaliq-core
```
## Status
🚧 **Active Development** - This repository is currently in active development, which involves:
- migrating functionality from the legacy monolithic [discovery repo](https://github.com/causaliq/discovery)
- restructuring classes to reduce module size and improve maintainability and improve usability
- ensure CausalIQ development standards are met
- adding new core functionality required by several CausalIQ packages
## Features
Currently implemented:
- **Release v0.1.0 - Foundation and utilities**: CausalIQ compliant development environment and utility functions (timing, random numbers, environment detection, etc.)
- **Release v0.2.0 - Graph classes**: Graph types for causal discovery including Summary Dependence Graphs (SDG), Partially Directed Acyclic Graphs (PDAG), Directed Acyclic Graphs (DAG), with conversion utilities and I/O support for Tetrad/Bayesys formats
- **Release v0.3.0 - Bayesian Networks**: support for Bayesian Networks and their parameterised distributions and I/O support for DSC and XDSL formats
- **Release v0.4.0 - Caching Infrastructure** [February 2026]: Token-based caching and (de)compression of JSON and GraphML.
Upcoming releases:
- none planned
## Quick Start
```python
from causaliq_core.graph import PDAG, read, write
# Create a partially directed graph
pdag = PDAG(['X', 'Y', 'Z'], [('X', '->', 'Y'), ('Y', '--', 'Z')])
# Save and load graphs
write(pdag, "my_graph.csv") # Bayesys format
loaded_graph = read("my_graph.csv")
# Convert between graph types
from causaliq_core.graph import extend_pdag
dag = extend_pdag(pdag) # Extend PDAG to DAG
```
## Getting started
### Prerequisites
- Git
- Latest stable versions of Python 3.9, 3.10. 3.11, 3.12 and 3.13
### Clone the new repo locally and check that it works
Clone the causaliq-core repo locally as normal
```bash
git clone https://github.com/causaliq/causaliq-core.git
```
Set up the Python virtual environments and activate the default Python virtual environment. You may see
messages from VSCode (if you are using it as your IDE) that new Python environments are being created
as the scripts/setup-env runs - these messages can be safely ignored at this stage.
```text
scripts/setup-env -Install
scripts/activate
```
Check that the causaliq-core CLI is working, check that all CI tests pass, and start up the local mkdocs webserver. There should be no errors reported in any of these.
```text
causaliq-core --help
scripts/check_ci
mkdocs serve
```
Enter **http://127.0.0.1:8000/** in a browser and check that the
causaliq-core documentation is visible.
If all of the above works, this confirms that the code is working successfully on your system.
### Start work on new features
The real work of implementing the functionality of this new CausalIQ package can now begin!
## Documentation
Full API documentation is available at: **http://127.0.0.1:8000/** (when running `mkdocs serve`)
## Contributing
This repository is part of the CausalIQ ecosystem. For development setup:
1. Clone the repository
2. Run `scripts/setup-env -Install` to set up environments
3. Run `scripts/check_ci` to verify all tests pass
4. Start documentation server with `mkdocs serve`
---
**Supported Python Versions**: 3.9, 3.10, 3.11, 3.12 , 3.13
**Default Python Version**: 3.11
**License**: MIT
| text/markdown | null | CausalIQ <info@causaliq.org> | null | "Dr. Ken Kitson" <info@causaliq.org> | null | causaliq | [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Science/Research",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Languag... | [] | null | null | >=3.9 | [] | [] | [] | [
"click>=8.0.0",
"numpy>=1.20.0",
"pandas>=1.3.0",
"platformdirs>=3.0.0",
"py-cpuinfo>=9.0.0",
"psutil>=5.8.0",
"scikit-learn>=1.0.0",
"pytest>=7.0.0; extra == \"dev\"",
"pytest-cov>=4.0.0; extra == \"dev\"",
"pytest-mock>=3.10.0; extra == \"dev\"",
"black>=22.0.0; extra == \"dev\"",
"isort>=5.... | [] | [] | [] | [
"Homepage, https://github.com/causaliq/causaliq-core",
"Documentation, https://github.com/causaliq/causaliq-core#readme",
"Repository, https://github.com/causaliq/causaliq-core",
"Bug Tracker, https://github.com/causaliq/causaliq-core/issues"
] | twine/6.2.0 CPython/3.11.9 | 2026-02-18T09:56:10.249752 | causaliq_core-0.4.0.tar.gz | 80,883 | fe/a5/6692341a7c933ccc75b77d149142c55baf95834baa23315489bc9c45d599/causaliq_core-0.4.0.tar.gz | source | sdist | null | false | 991e4a49da6174995c3acf65758f91ad | ea20eb242af11fa23d7c9a908bace97b092b6e2dbd9f5871c1a12d19746fdf88 | fea56692341a7c933ccc75b77d149142c55baf95834baa23315489bc9c45d599 | MIT | [
"LICENSE"
] | 315 |
2.4 | opengater-globalauth-client | 0.2.15 | Client library for GlobalAuth authentication service | # opengater-globalauth-client
Python client library for GlobalAuth authentication service.
## Features
- 🔐 HTTP client for token validation and referral operations
- 🐰 RabbitMQ integration for events and commands
- ⚡ FastAPI middleware and dependencies
- 💾 Built-in caching for introspect results
- 🔄 Async-first design
## Installation
```bash
pip install opengater-globalauth-client
```
Or with uv:
```bash
uv add opengater-globalauth-client
```
## Quick Start
### HTTP Client
```python
from opengater_globalauth_client import GlobalAuthClient
client = GlobalAuthClient(
base_url="https://auth.example.com",
service_slug="opengater",
cache_ttl=300 # Cache introspect results for 5 minutes
)
# Validate token
user = await client.introspect(token)
print(f"User: {user.id}, verified: {user.verified}")
# Decode referral code
ref_info = await client.decode_referral("ref_xxx")
if ref_info.type == "referral":
print(f"Invited by: {ref_info.inviter_id}")
# Get referral link for user
link = await client.get_referral_link(user_token)
print(f"Share this link: {link.link}")
# Get referral stats
stats = await client.get_referral_stats(user_token)
print(f"Total invited: {stats.total_invited}")
```
### RabbitMQ Integration
```python
from faststream.rabbit import RabbitBroker
from opengater_globalauth_client.broker import (
GlobalAuthConsumer,
GlobalAuthPublisher,
UserCreatedEvent,
)
# Use your existing broker
broker = RabbitBroker(settings.rabbitmq_url)
# Consumer for events
consumer = GlobalAuthConsumer(broker, "globalauth.opengater")
@consumer.on_user_created
async def handle_user_created(event: UserCreatedEvent):
print(f"New user: {event.user_id}")
if event.invited_by_id:
# Award referral bonus
await award_bonus(event.invited_by_id)
@consumer.on_auth_method_linked
async def handle_linked(event):
print(f"User {event.user_id} linked {event.auth_type}")
# Publisher for commands
publisher = GlobalAuthPublisher(broker)
# Create user from Telegram bot
await publisher.create_user(
auth_type="telegram",
identifier="123456789",
extra_data={"username": "john", "first_name": "John"},
invited_by_id="uuid-of-inviter"
)
```
### FastAPI Integration
#### With Middleware (Recommended)
```python
from fastapi import FastAPI, Depends, Request
from opengater_globalauth_client import GlobalAuthClient
from opengater_globalauth_client.fastapi import AuthMiddleware, get_current_user
app = FastAPI()
client = GlobalAuthClient(
base_url="https://auth.example.com",
service_slug="opengater"
)
# Add middleware for automatic token validation
app.add_middleware(
AuthMiddleware,
client=client,
exclude_paths=["/health", "/public/*"] # Optional
)
@app.get("/me")
async def me(user = Depends(get_current_user())):
return {
"id": user.id,
"verified": user.verified,
"trust_level": user.trust.level
}
@app.get("/admin-only")
async def admin_only(user = Depends(require_admin())):
return {"message": "Welcome, admin!"}
```
#### Without Middleware
```python
from fastapi import FastAPI, Depends
from opengater_globalauth_client import GlobalAuthClient
from opengater_globalauth_client.fastapi import get_current_user
app = FastAPI()
client = GlobalAuthClient(
base_url="https://auth.example.com",
service_slug="opengater"
)
# Pass client to dependency
@app.get("/me")
async def me(user = Depends(get_current_user(client))):
return {"id": user.id}
```
## Available Events
| Event | Description |
|-------|-------------|
| `user_created` | New user registered |
| `auth_method_linked` | User linked auth method (email, telegram) |
| `auth_method_unlinked` | User unlinked auth method |
| `user_banned` | User was banned |
| `user_unbanned` | User was unbanned |
## User Model
```python
class User:
id: str
verified: bool
is_banned: bool
is_admin: bool
trust: TrustInfo # score, level
auth_methods: list[AuthMethod]
invited_by_id: str | None
registered_via_event: str | None
registered_via_service: str | None
```
## Configuration
| Parameter | Description | Default |
|-----------|-------------|---------|
| `base_url` | GlobalAuth service URL | Required |
| `service_slug` | Your service identifier | Required |
| `cache_ttl` | Introspect cache TTL (seconds) | 300 |
| `timeout` | HTTP timeout (seconds) | 30 |
## Error Handling
```python
from opengater_globalauth_client import (
GlobalAuthClient,
TokenExpiredError,
TokenInvalidError,
UserBannedError,
ConnectionError,
)
try:
user = await client.introspect(token)
except TokenExpiredError:
# Token expired, need to refresh
pass
except UserBannedError:
# User is banned
pass
except TokenInvalidError:
# Invalid token
pass
except ConnectionError:
# GlobalAuth service unavailable
pass
```
## License
MIT
| text/markdown | Opengater | null | null | null | MIT | auth, authentication, fastapi, rabbitmq | [
"Development Status :: 4 - Beta",
"Framework :: FastAPI",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
... | [] | null | null | >=3.11 | [] | [] | [] | [
"fastapi>=0.100.0",
"faststream[rabbit]>=0.5.0",
"httpx>=0.27.0",
"pydantic>=2.0.0"
] | [] | [] | [] | [
"Homepage, https://github.com/opengater/globalauth-client",
"Documentation, https://github.com/opengater/globalauth-client#readme"
] | twine/6.2.0 CPython/3.13.8 | 2026-02-18T09:55:17.171329 | opengater_globalauth_client-0.2.15.tar.gz | 15,867 | cd/e8/026a1954a706e090a8ca59a83ddfea0cf0025b35f23b5f55cafdec5193eb/opengater_globalauth_client-0.2.15.tar.gz | source | sdist | null | false | 1b1eea3c79dd01cd16f6b3b2b9f80535 | a884b11fdafc3e1fb7bfb51ea3d3b877b360d3191c5c29dfa414036cc49c72ab | cde8026a1954a706e090a8ca59a83ddfea0cf0025b35f23b5f55cafdec5193eb | null | [] | 259 |
2.4 | planoai | 0.4.8 | Python-based CLI tool to manage Plano. | ## plano CLI - Local Development
This guide will walk you through setting up the plano CLI for local development using uv.
### Install uv
First, install the uv package manager. This is required for managing dependencies and running the development version of planoai.
**On macOS and Linux:**
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```
**On Windows:**
```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```
### Setup
1. **Install dependencies**
In the cli directory, run:
```bash
uv sync
```
This will create a virtual environment in `.venv` and install all dependencies from `pyproject.toml`.
2. **Install the CLI tool globally (optional)**
To install planoai as a global tool on your system:
```bash
uv tool install --editable .
```
This installs planoai globally in editable mode, allowing you to run `planoai` commands from anywhere while still using the source code from this directory. Any changes you make to the code will be reflected immediately.
3. **Run plano commands**
Use `uv run` to execute plano commands with the development version:
```bash
uv run planoai build
```
Or, if you installed globally with `uv tool install .`:
```bash
planoai build
```
Note: `uv run` automatically uses the virtual environment - no activation needed.
### Development Workflow
**Build plano:**
```bash
uv run planoai build
```
**View logs:**
```bash
uv run planoai logs --follow
```
**Run other plano commands:**
```bash
uv run planoai <command> [options]
```
### CI: Keep CLI templates and demos in sync
The CLI templates in `cli/planoai/templates/` are the source of truth for mapped
demo `config.yaml` files.
Use the sync utility to write mapped demo configs from templates:
```bash
uv run python -m planoai.template_sync
```
### Optional: Manual Virtual Environment Activation
While `uv run` handles the virtual environment automatically, you can activate it manually if needed:
```bash
source .venv/bin/activate
planoai build # No need for 'uv run' when activated
```
**Note:** For end-user installation instructions, see the [Plano documentation](https://docs.planoai.dev).
| text/markdown | Katanemo Labs, Inc. | null | null | null | null | null | [] | [] | null | null | >=3.10 | [] | [] | [] | [
"click<9.0.0,>=8.1.7",
"grpcio>=1.60.0",
"jinja2<4.0.0,>=3.1.4",
"jsonschema<5.0.0,>=4.23.0",
"opentelemetry-proto>=1.20.0",
"pyyaml<7.0.0,>=6.0.2",
"questionary<3.0.0,>=2.1.1",
"requests<3.0.0,>=2.31.0",
"rich-click>=1.9.5",
"rich>=14.2.0",
"urllib3>=2.6.3",
"pytest<9.0.0,>=8.4.1; extra == \"... | [] | [] | [] | [] | 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-18T09:54:27.289754 | planoai-0.4.8-py3-none-any.whl | 42,521 | 3e/44/b54cba948264f85a6b21aa72c8d150aaf3c4a875b90f8f4b4d299e5623e1/planoai-0.4.8-py3-none-any.whl | py3 | bdist_wheel | null | false | db5eef8792166824c5c2e429d91ec909 | 2a362b247c6f991d724dcc6be83d34d354114d932ff186d71889222f78d2c1ce | 3e44b54cba948264f85a6b21aa72c8d150aaf3c4a875b90f8f4b4d299e5623e1 | null | [] | 272 |
2.4 | swarmauri_vectorstore_redis | 0.9.2.dev4 | Swarmauri Redis Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_redis/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_redis" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_redis/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_redis.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_redis/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_redis" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_redis/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_redis" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_redis/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_redis?label=swarmauri_vectorstore_redis&color=green" alt="PyPI - swarmauri_vectorstore_redis"/></a>
</p>
---
# Swarmauri Vectorstore Redis
A Redis-based vector store implementation for the Swarmauri SDK that enables efficient storage and retrieval of document embeddings.
## Installation
```bash
pip install swarmauri_vectorstore_redis
```
## Usage
Basic example of using RedisVectorStore:
```python
from swarmauri.vector_stores.RedisVectorStore import RedisVectorStore
from swarmauri.documents.Document import Document
# Initialize the vector store
vector_store = RedisVectorStore(
redis_host="localhost",
redis_port=6379,
redis_password="your_password",
embedding_dimension=8000
)
# Add documents
document = Document(
id="doc1",
content="Sample document content",
metadata={"category": "sample"}
)
vector_store.add_document(document)
# Retrieve similar documents
similar_docs = vector_store.retrieve("sample content", top_k=5)
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, redis, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"redis>=4.0",
"redisearch",
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:53:02.848289 | swarmauri_vectorstore_redis-0.9.2.dev4.tar.gz | 9,133 | a6/40/88ae9d6638c0991c45b1120fff834a88769c583480dc1fcc78f8a4e074ba/swarmauri_vectorstore_redis-0.9.2.dev4.tar.gz | source | sdist | null | false | 294ce26a86b4213fc5c7ba62ad6c61d8 | dae6d80182da8ed353400d2e2555f216ce925a361325c3d4a64895585c95d38f | a64088ae9d6638c0991c45b1120fff834a88769c583480dc1fcc78f8a4e074ba | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_qdrant | 0.9.2.dev4 | Swarmauri Persistent Qdrant Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_qdrant/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_qdrant" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_qdrant/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_qdrant.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_qdrant/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_qdrant" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_qdrant/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_qdrant" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_qdrant/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_qdrant?label=swarmauri_vectorstore_qdrant&color=green" alt="PyPI - swarmauri_vectorstore_qdrant"/></a>
</p>
---
# Swarmauri Vectorstore Qdrant
A vector store implementation using Qdrant as the backend, supporting both persistent local storage and cloud-based operations for document storage and retrieval.
## Installation
```bash
pip install swarmauri_vectorstore_qdrant
```
## Usage
```python
from swarmauri.documents.Document import Document
from swarmauri.vectorstores.PersistentQdrantVectorStore import PersistentQdrantVectorStore
from swarmauri.vector_stores.CloudQdrantVectorStore import CloudQdrantVectorStore
# Local Persistent Storage
local_store = PersistentQdrantVectorStore(
collection_name="my_collection",
vector_size=100,
path="http://localhost:6333"
)
local_store.connect()
# Cloud Storage
cloud_store = CloudQdrantVectorStore(
api_key="your_api_key",
collection_name="my_collection",
vector_size=100,
url="your_qdrant_cloud_url"
)
cloud_store.connect()
# Add documents
documents = [
Document(content="sample text 1"),
Document(content="sample text 2")
]
local_store.add_documents(documents)
# Retrieve similar documents
results = local_store.retrieve("sample query", top_k=5)
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, qdrant, persistent, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"qdrant-client>=1.12.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:46.691346 | swarmauri_vectorstore_qdrant-0.9.2.dev4.tar.gz | 8,757 | 5c/2e/10a9165027d134555a6d9a339cc440a1183123c013307c9d7338bb99cb54/swarmauri_vectorstore_qdrant-0.9.2.dev4.tar.gz | source | sdist | null | false | a0b398699d0c3dde26d8798d60264e0e | 1d1bf15a9ee46bf70df682a8e61d18851faec6fe27105a811302022fcea62e51 | 5c2e10a9165027d134555a6d9a339cc440a1183123c013307c9d7338bb99cb54 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_pinecone | 0.9.3.dev5 | Swarmauri Pinecone Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_pinecone/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_pinecone" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_pinecone/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_pinecone.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_pinecone/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_pinecone" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_pinecone/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_pinecone" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_pinecone/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_pinecone?label=swarmauri_vectorstore_pinecone&color=green" alt="PyPI - swarmauri_vectorstore_pinecone"/></a>
</p>
---
# Swarmauri Vectorstore Pinecone
A vector store implementation using Pinecone as the backend for efficient similarity search and document storage.
## Installation
```bash
pip install swarmauri_vectorstore_pinecone
```
## Usage
```python
from swarmauri.vector_stores.PineconeVectorStore import PineconeVectorStore
from swarmauri.documents.Document import Document
# Initialize vector store
vector_store = PineconeVectorStore(
api_key="your-pinecone-api-key",
collection_name="example",
vector_size=100
)
vector_store.connect()
# Add documents
documents = [
Document(content="First document"),
Document(content="Second document"),
]
vector_store.add_documents(documents)
# Retrieve similar documents
results = vector_store.retrieve(query="document", top_k=2)
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, pinecone, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"pinecone[grpc]>=5.0.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:44.787391 | swarmauri_vectorstore_pinecone-0.9.3.dev5-py3-none-any.whl | 10,107 | 95/42/543c13bb8ac8ca40cc3a5215e6de2e6f238173ca77f94564c1f70e6f1ffb/swarmauri_vectorstore_pinecone-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | 2fb2365baefc3d668ca24ef22c02ead6 | d28b6ca6977cc7c70ac8cf8a60c69881699c9c55b06ea260891a57b88196d743 | 9542543c13bb8ac8ca40cc3a5215e6de2e6f238173ca77f94564c1f70e6f1ffb | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_persistentchromadb | 0.9.3.dev5 | A Persistent ChromaDB based Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_persistentchromadb/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_persistentchromadb" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_persistentchromadb/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_persistentchromadb.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_persistentchromadb/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_persistentchromadb" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_persistentchromadb/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_persistentchromadb" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_persistentchromadb/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_persistentchromadb?label=swarmauri_vectorstore_persistentchromadb&color=green" alt="PyPI - swarmauri_vectorstore_persistentchromadb"/></a>
</p>
---
# Swarmauri Vectorstore Persistentchromadb
A persistent vector store implementation using ChromaDB for document storage and retrieval with embeddings.
## Installation
```bash
pip install swarmauri_vectorstore_persistentchromadb
```
## Usage
```python
from swarmauri.documents.Document import Document
from swarmauri.vector_stores.PersistentChromaDBVectorStore import PersistentChromaDBVectorStore
# Initialize the vector store
vector_store = PersistentChromaDBVectorStore(
path="./chromadb_data",
collection_name="my_collection",
vector_size=100
)
# Connect to the store
vector_store.connect()
# Add documents
documents = [
Document(content="first document"),
Document(content="second document"),
Document(content="third document")
]
vector_store.add_documents(documents)
# Retrieve similar documents
results = vector_store.retrieve(query="document", top_k=2)
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, persistentchromadb, persistent, chromadb, based, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"chromadb>=0.5.17",
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:43.421866 | swarmauri_vectorstore_persistentchromadb-0.9.3.dev5.tar.gz | 7,952 | d8/3e/aeba98554c62ebc0162e7df201414f0e1e418ede2833b92903ddc69e68f1/swarmauri_vectorstore_persistentchromadb-0.9.3.dev5.tar.gz | source | sdist | null | false | d54c5266d8934df89541f57a53f0163e | c2e00d2a51a6858d72e1ff7c51ad1f8851006b9e8035bfd9e8d503b41870fca3 | d83eaeba98554c62ebc0162e7df201414f0e1e418ede2833b92903ddc69e68f1 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_mlm | 0.9.3.dev5 | Swarmauri MLM Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_mlm/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_mlm" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_mlm/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_mlm.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_mlm/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_mlm" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_mlm/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_mlm" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_mlm/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_mlm?label=swarmauri_vectorstore_mlm&color=green" alt="PyPI - swarmauri_vectorstore_mlm"/></a>
</p>
---
# Swarmauri Vectorstore Mlm
A vector store implementation using MLM (Masked Language Model) embeddings for document storage and retrieval.
## Installation
```bash
pip install swarmauri_vectorstore_mlm
```
## Usage
Here's a basic example of how to use the MLM Vector Store:
```python
from swarmauri.documents.Document import Document
from swarmauri.vector_stores.MlmVectorStore import MlmVectorStore
# Initialize the vector store
vs = MlmVectorStore()
# Create some documents
documents = [
Document(content="first document"),
Document(content="second document"),
Document(content="third document")
]
# Add documents to the store
vs.add_documents(documents)
# Retrieve similar documents
results = vs.retrieve(query="document", top_k=2)
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, mlm, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_mlm",
"swarmauri_standard",
"torch>=2.4.1",
"transformers>=4.45.0"
] | [] | [] | [] | [] | 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-18T09:52:42.445850 | swarmauri_vectorstore_mlm-0.9.3.dev5.tar.gz | 7,029 | 5d/e8/219fc6c11f1ce357db3d9711740c8518c430548597e249045e65711a1951/swarmauri_vectorstore_mlm-0.9.3.dev5.tar.gz | source | sdist | null | false | 5c13cac0dcee0c74573cf39f7e4dc5c3 | 2d483c391f3e51eb216913e5c6314a8d98cf3118df0a615309740c5bcabb6fec | 5de8219fc6c11f1ce357db3d9711740c8518c430548597e249045e65711a1951 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_neo4j | 0.9.3.dev5 | Swarmauri Neo4j Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_neo4j/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_neo4j" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_neo4j/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_neo4j.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_neo4j/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_neo4j" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_neo4j/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_neo4j" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_neo4j/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_neo4j?label=swarmauri_vectorstore_neo4j&color=green" alt="PyPI - swarmauri_vectorstore_neo4j"/></a>
</p>
---
# Swarmauri Vectorstore Neo4j
A Neo4j-based vector store implementation for Swarmauri SDK, providing document storage and retrieval functionality using Neo4j graph database.
## Installation
```bash
pip install swarmauri_vectorstore_neo4j
```
## Usage
```python
from swarmauri.documents.Document import Document
from swarmauri.vector_stores.Neo4jVectorStore import Neo4jVectorStore
# Initialize the vector store
store = Neo4jVectorStore(
uri="neo4j://localhost:7687",
user="neo4j",
password="your_password"
)
# Add a document
doc = Document(
id="doc1",
content="Sample content",
metadata={"author": "John Doe"}
)
store.add_document(doc)
# Retrieve similar documents
similar_docs = store.retrieve(query="sample", top_k=5)
# Close connection when done
store.close()
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, neo4j, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"neo4j>=5.25.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:41.399824 | swarmauri_vectorstore_neo4j-0.9.3.dev5.tar.gz | 7,796 | 16/72/0c1e734c6f28810211adb1e76c792d0b72608a5550cbd16610210aa8195c/swarmauri_vectorstore_neo4j-0.9.3.dev5.tar.gz | source | sdist | null | false | b840d60fb55894ddfe20566f75ae8e6a | e8dd1e3ee39e0072a3033e7e4ef29b2ab131aa58c0a1f0b21baae1d4d0f12079 | 16720c1e734c6f28810211adb1e76c792d0b72608a5550cbd16610210aa8195c | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_cloudweaviate | 0.9.3.dev5 | Swarmauri Weaviate Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_cloudweaviate/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_cloudweaviate" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_cloudweaviate/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_cloudweaviate.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_cloudweaviate/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_cloudweaviate" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_cloudweaviate/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_cloudweaviate" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_cloudweaviate/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_cloudweaviate?label=swarmauri_vectorstore_cloudweaviate&color=green" alt="PyPI - swarmauri_vectorstore_cloudweaviate"/></a>
</p>
---
# Swarmauri Vectorstore CloudWeaviate
A Weaviate-based vector store implementation for Swarmauri, providing cloud-based document storage and retrieval with vector similarity search capabilities.
## Installation
```bash
pip install swarmauri_vectorstore_cloudweaviate
```
## Usage
Here's a basic example of how to use the CloudWeaviateVectorStore:
```python
from swarmauri.vector_stores.CloudWeaviateVectorStore import CloudWeaviateVectorStore
from swarmauri.documents.Document import Document
# Initialize the vector store
vector_store = CloudWeaviateVectorStore(
url="your-weaviate-url",
api_key="your-api-key",
collection_name="example",
vector_size=100
)
# Connect to Weaviate
vector_store.connect()
# Add documents
document = Document(
id="doc-001",
content="This is a sample document content.",
metadata={"author": "Alice", "date": "2024-01-01"}
)
vector_store.add_document(document)
# Retrieve similar documents
results = vector_store.retrieve(query="sample content", top_k=5)
# Clean up
vector_store.disconnect()
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, cloudweaviate, weaviate, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard",
"weaviate-client>=4.9.2"
] | [] | [] | [] | [] | 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-18T09:52:25.328086 | swarmauri_vectorstore_cloudweaviate-0.9.3.dev5.tar.gz | 8,266 | 2f/99/985365a86ab0a7694ca34551a8dd2a9f162a7b66e1e4e9cc5398149071d3/swarmauri_vectorstore_cloudweaviate-0.9.3.dev5.tar.gz | source | sdist | null | false | 2b839614295f9db0e82dcb540e463260 | 9d8ce7331115515b31e6f6eba4ddcd2be2e1450cf4a7334560972b4d1e78fcb7 | 2f99985365a86ab0a7694ca34551a8dd2a9f162a7b66e1e4e9cc5398149071d3 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_duckdb | 0.9.3.dev5 | A DuckDB based Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_duckdb/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_duckdb" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_duckdb/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_duckdb.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_duckdb/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_duckdb" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_duckdb/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_duckdb" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_duckdb/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_duckdb?label=swarmauri_vectorstore_duckdb&color=green" alt="PyPI - swarmauri_vectorstore_duckdb"/></a>
</p>
---
# Swarmauri Vectorstore Duckdb
A vector store implementation using DuckDB as the backend for efficient document storage and similarity search.
## Installation
```bash
pip install swarmauri_vectorstore_duckdb
```
## Usage
```python
from swarmauri.vector_stores.DuckDBVectorStore import DuckDBVectorStore
from swarmauri.documents.Document import Document
# Initialize vector store
vector_store = DuckDBVectorStore(database_name="my_vectors.db")
vector_store.connect()
# Add documents
doc = Document(
id="doc1",
content="The quick brown fox jumps over the lazy dog",
metadata={"type": "example"}
)
vector_store.add_document(doc)
# Retrieve similar documents
results = vector_store.retrieve("fox jumping", top_k=2)
# Clean up
vector_store.disconnect()
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, duckdb, based, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"duckdb>=1.1.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:22.992318 | swarmauri_vectorstore_duckdb-0.9.3.dev5.tar.gz | 8,651 | 65/22/3bb4e5e257c01eb38623adcf4772d2e7320468be7a9628a8bf563459eb57/swarmauri_vectorstore_duckdb-0.9.3.dev5.tar.gz | source | sdist | null | false | 18fa397ba61cd40911fed6fdf0c73352 | bea4e5c94066473b15e783a5da54efbf5eb083abd6e91fac2f1ba1c49035aa71 | 65223bb4e5e257c01eb38623adcf4772d2e7320468be7a9628a8bf563459eb57 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_toolkit_jupytertoolkit | 0.3.3.dev5 | A unified toolkit for aggregating standalone jupyter notebook tools. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_toolkit_jupytertoolkit/">
<img src="https://img.shields.io/pypi/dm/swarmauri_toolkit_jupytertoolkit" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_toolkit_jupytertoolkit/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_toolkit_jupytertoolkit.svg"/></a>
<a href="https://pypi.org/project/swarmauri_toolkit_jupytertoolkit/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_toolkit_jupytertoolkit" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_toolkit_jupytertoolkit/">
<img src="https://img.shields.io/pypi/l/swarmauri_toolkit_jupytertoolkit" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_toolkit_jupytertoolkit/">
<img src="https://img.shields.io/pypi/v/swarmauri_toolkit_jupytertoolkit?label=swarmauri_toolkit_jupytertoolkit&color=green" alt="PyPI - swarmauri_toolkit_jupytertoolkit"/></a>
</p>
---
# Swarmauri Toolkit · Jupyter Toolkit
A one-stop Swarmauri toolkit that bundles the Jupyter kernel, execution, export, and validation tools under a single interface. Instantiate `JupyterToolkit` and you instantly gain access to twenty standalone tools covering notebook lifecycle tasks: launching kernels, running cells, converting notebooks, exporting formats, and more.
- Pre-registers commonly used Jupyter utilities such as `JupyterStartKernelTool`, `JupyterExecuteNotebookTool`, `JupyterExportHtmlTool`, and `JupyterShutdownKernelTool`.
- Ensures each tool shares the same Swarmauri component metadata so agents can discover capabilities automatically.
- Useful for agents, pipelines, or CLI scripts that need rich notebook automation without manually wiring every tool.
## Requirements
- Python 3.10 – 3.13.
- The underlying Jupyter tool packages (installed automatically as dependencies).
- Access to a local or remote Jupyter runtime for kernel operations.
## Installation
Pick the package manager that fits your project; each command installs the toolkit plus all underlying Jupyter tools.
**pip**
```bash
pip install swarmauri_toolkit_jupytertoolkit
```
**Poetry**
```bash
poetry add swarmauri_toolkit_jupytertoolkit
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_toolkit_jupytertoolkit
# or install into the active environment without modifying pyproject.toml
uv pip install swarmauri_toolkit_jupytertoolkit
```
> Tip: Some tools depend on Jupyter client libraries (`jupyter_client`, `nbformat`, `nbconvert`). Make sure your environment includes any system packages required by those libraries (for example LaTeX when exporting to PDF/LaTeX).
## Quick Start
```python
from swarmauri_toolkit_jupytertoolkit import JupyterToolkit
toolkit = JupyterToolkit()
# Start a kernel and execute a notebook
start = toolkit.tools["JupyterStartKernelTool"]()
print(start)
run = toolkit.tools["JupyterExecuteNotebookTool"](
notebook_path="reports/daily.ipynb",
timeout=120
)
print(run)
# Export the executed notebook to HTML
export = toolkit.tools["JupyterExportHtmlTool"](
notebook_path="reports/daily.ipynb",
output_path="reports/daily.html"
)
print(export)
# Gracefully shut down the kernel
shutdown = toolkit.tools["JupyterShutdownKernelTool"](
kernel_id=start["kernel_id"],
shutdown_timeout=10
)
print(shutdown)
```
`JupyterToolkit.tools` is a dictionary keyed by tool name. Each entry is the ready-to-call Swarmauri tool instance.
## Usage Scenarios
### Build a Notebook Orchestration Service
```python
from fastapi import FastAPI, BackgroundTasks
from swarmauri_toolkit_jupytertoolkit import JupyterToolkit
app = FastAPI()
toolkit = JupyterToolkit()
@app.post("/execute")
def execute(data: dict, background: BackgroundTasks):
nb_path = data["notebook_path"]
background.add_task(
toolkit.tools["JupyterExecuteNotebookWithParametersTool"],
notebook_path=nb_path,
parameters=data.get("parameters", {})
)
return {"status": "queued", "notebook": nb_path}
```
Trigger parameterized notebook runs via HTTP and reuse the toolkit’s pre-wired execution tool.
### Enhance a Swarmauri Agent With Notebook Skills
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_toolkit_jupytertoolkit import JupyterToolkit
jupyter_toolkit = JupyterToolkit()
registry = ToolRegistry()
registry.register(jupyter_toolkit.tools["JupyterExecuteCellTool"])
registry.register(jupyter_toolkit.tools["JupyterReadNotebookTool"])
registry.register(jupyter_toolkit.tools["JupyterWriteNotebookTool"])
agent = Agent(tool_registry=registry)
response = agent.run(HumanMessage(content="Execute cell 3 from analytics.ipynb"))
print(response)
```
Combine multiple notebook operations so the agent can read, modify, and execute notebooks within a single conversation.
### Convert Notebooks in Bulk
```python
from pathlib import Path
from swarmauri_toolkit_jupytertoolkit import JupyterToolkit
toolkit = JupyterToolkit()
export_html = toolkit.tools["JupyterExportHtmlTool"]
export_md = toolkit.tools["JupyterExportMarkdownTool"]
for notebook in Path("notebooks").glob("*.ipynb"):
export_html(notebook_path=str(notebook), output_path=str(notebook.with_suffix(".html")))
export_md(notebook_path=str(notebook), output_path=str(notebook.with_suffix(".md")))
```
Run multiple exporters without manually instantiating each tool.
## Troubleshooting
- **Kernel start failures** – Ensure the environment has a working Jupyter kernelspec (e.g., `python3`). Check permissions when running inside containers or restricted hosts.
- **Export errors** – Some exporters (LaTeX/PDF) require external dependencies. Install TeX Live or pandoc as appropriate.
- **Tool lookup mistakes** – Use `toolkit.tools.keys()` to inspect available tool names; they map 1:1 to the underlying packages (`JupyterExecuteNotebookTool`, `JupyterValidateNotebookTool`, etc.).
## License
`swarmauri_toolkit_jupytertoolkit` is released under the Apache 2.0 License. See `LICENSE` for details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, toolkit, jupytertoolkit, unified, aggregating, standalone, jupyter, notebook, tools | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"pydantic",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard",
"swarmauri_tool_jupyterclearoutput",
"swarmauri_tool_jupyterdisplay",
"swarmauri_tool_jupyterdisplayhtml",
"swarmauri_tool_jupyterexecuteandconvert",
"swarmauri_tool_jupyterexecutecell",
"swarmauri_tool_jupyterexecutenotebook",
... | [] | [] | [] | [] | 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-18T09:52:20.880976 | swarmauri_toolkit_jupytertoolkit-0.3.3.dev5-py3-none-any.whl | 9,659 | 37/25/9049b3b40da0fa92ddc141167236bf06d9eb77300a3c9fcb36794c29f0ca/swarmauri_toolkit_jupytertoolkit-0.3.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | 9c81e3e5883f6858ab62bcb4008ba520 | 0dc3fa06fd14764d9c2f1e4442afdd79b79c44197b204b1edb22d0eea112a5d5 | 37259049b3b40da0fa92ddc141167236bf06d9eb77300a3c9fcb36794c29f0ca | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_vectorstore_annoy | 0.9.3.dev5 | Swarmauri Annoy Vector Store |
<p align="center">
<a href="https://pypi.org/project/swarmauri_vectorstore_annoy/">
<img src="https://img.shields.io/pypi/dm/swarmauri_vectorstore_annoy" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_annoy/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_vectorstore_annoy.svg"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_annoy/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_annoy" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_annoy/">
<img src="https://img.shields.io/pypi/l/swarmauri_vectorstore_annoy" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_vectorstore_annoy/">
<img src="https://img.shields.io/pypi/v/swarmauri_vectorstore_annoy?label=swarmauri_vectorstore_annoy&color=green" alt="PyPI - swarmauri_vectorstore_annoy"/></a>
</p>
---
# Swarmauri VectorStore Annoy
A vector store implementation using Annoy as the backend for efficient similarity search and nearest neighbor queries.
## Installation
```bash
pip install swarmauri_vectorstore_annoy
```
## Usage
```python
from swarmauri.vector_stores.AnnoyVectorStore import AnnoyVectorStore
from swarmauri_standard.documents.Document import Document
# Initialize vector store
vector_store = AnnoyVectorStore(
collection_name="my_collection",
vector_size=100
)
vector_store.connect()
# Add documents
documents = [
Document(content="first document"),
Document(content="second document"),
Document(content="third document")
]
vector_store.add_documents(documents)
# Retrieve similar documents
results = vector_store.retrieve(query="document", top_k=2)
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, vectorstore, annoy, vector, store | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"annoy>=1.17.3",
"swarmauri_base",
"swarmauri_core",
"swarmauri_embedding_doc2vec",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:19.902512 | swarmauri_vectorstore_annoy-0.9.3.dev5.tar.gz | 8,423 | 4a/2a/cc8a0a8438bbc6f054c679420ca73146be2aa8466881dca53cd59092f1bd/swarmauri_vectorstore_annoy-0.9.3.dev5.tar.gz | source | sdist | null | false | bd77e7d2e8f9fda98537fb0213e4ebda | 4ab4c6c293cd5b3a59afbe56ef988a00d90355a8dad5973f5b334b35928b1d32 | 4a2acc8a0a8438bbc6f054c679420ca73146be2aa8466881dca53cd59092f1bd | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_toolkit_github | 0.8.3.dev5 | Github Toolkit | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_toolkit_github/">
<img src="https://img.shields.io/pypi/dm/swarmauri_toolkit_github" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_toolkit_github/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_toolkit_github.svg"/></a>
<a href="https://pypi.org/project/swarmauri_toolkit_github/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_toolkit_github" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_toolkit_github/">
<img src="https://img.shields.io/pypi/l/swarmauri_toolkit_github" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_toolkit_github/">
<img src="https://img.shields.io/pypi/v/swarmauri_toolkit_github?label=swarmauri_toolkit_github&color=green" alt="PyPI - swarmauri_toolkit_github"/></a>
</p>
---
# Swarmauri Toolkit · GitHub
A Swarmauri toolkit that wraps PyGithub behind Swarmauri’s agent/tool abstractions. Authenticate once and gain access to repository, issue, pull request, branch, and commit helpers—ready for scripted automation or conversational agents.
- Creates a shared GitHub client so every tool call reuses the same token and rate-limit state.
- Normalizes responses into dictionaries so downstream logic can inspect status messages or raw PyGithub payloads.
- Covers common actions (create/list/update/delete) while staying extensible via the `action` parameter on each tool.
## Requirements
- Python 3.10 – 3.13.
- GitHub personal access token (classic or fine-grained) with the scopes your workflow requires. Store it in an environment variable such as `GITHUB_TOKEN`.
- Runtime dependencies (`PyGithub`, `python-dotenv`, and the Swarmauri base/standard packages) install automatically with the toolkit.
## Installation
Choose any of the supported packaging flows; each command resolves transitive dependencies.
**pip**
```bash
pip install swarmauri_toolkit_github
```
**Poetry**
```bash
poetry add swarmauri_toolkit_github
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_toolkit_github
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_toolkit_github
```
> Tip: `python-dotenv` is imported automatically—drop your token into a local `.env` file (`GITHUB_TOKEN=ghp_...`) for quick experimentation.
## Quick Start
```python
import os
from swarmauri_toolkit_github import GithubToolkit
toolkit = GithubToolkit(api_token=os.environ["GITHUB_TOKEN"])
# List repositories for the authenticated user
repos = toolkit.github_repo_tool(action="list_repos")
print(repos["list_repos"])
# Open a tracking issue
issue = toolkit.github_issue_tool(
action="create_issue",
repo_name="owner/example",
title="Investigate flaky tests",
body="Logs: https://gist.github.com/..."
)
print(issue["create_issue"])
```
Each sub-tool accepts an `action` argument (see PyGithub docs for additional options) and returns a dictionary keyed by that action for ergonomic unpacking.
## Usage Scenarios
### Automate Release Housekeeping
```python
from swarmauri_toolkit_github import GithubToolkit
toolkit = GithubToolkit(api_token=os.environ["GITHUB_TOKEN"])
# Create a release branch
toolkit.github_branch_tool(
action="create_branch",
repo_name="owner/service",
new_branch="release/v1.4.0",
source_branch="master"
)
# Cut a changelog commit
toolkit.github_commit_tool(
action="create_file",
repo_name="owner/service",
path="CHANGELOG.md",
message="Add release notes",
content="### v1.4.0\n- New features...",
branch="release/v1.4.0"
)
```
### Drive GitHub From a Swarmauri Agent
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_toolkit_github import GithubToolkit
toolkit = GithubToolkit(api_token=os.environ["GITHUB_TOKEN"])
registry = ToolRegistry()
registry.register(toolkit.github_issue_tool)
registry.register(toolkit.github_pr_tool)
agent = Agent(tool_registry=registry)
response = agent.run(HumanMessage(content="Open a PR from feature/auth to master"))
print(response)
```
Enable conversational workflows that translate natural-language requests into GitHub mutations.
### Triage Issues Nightly
```python
from datetime import datetime, timedelta
from swarmauri_toolkit_github import GithubToolkit
toolkit = GithubToolkit(api_token=os.environ["GITHUB_TOKEN"])
cutoff = datetime.utcnow() - timedelta(days=7)
issues = toolkit.github_issue_tool(
action="list",
repo_name="owner/product",
state="open"
)["list"]
stale = [issue for issue in issues if issue.updated_at < cutoff]
for issue in stale:
toolkit.github_issue_tool(
action="create_comment",
repo_name="owner/product",
number=issue.number,
body="Ping! Any update in the last week?"
)
```
Keep a backlog tidy by automatically nudging stale tickets.
## Troubleshooting
- **`ValueError: Invalid Token or Missing api_token`** – Pass the token explicitly (`GithubToolkit(api_token=...)`) or export `GITHUB_TOKEN` before instantiating the toolkit.
- **PyGithub exception messages** – Most actions bubble up PyGithub errors verbatim (permission issues, missing branches, etc.). Inspect the text in the returned string to resolve scope or naming problems.
- **GitHub rate limits** – PyGithub tracks remaining requests; consider batching actions or sleeping when `Github.get_rate_limit()` indicates low headroom.
## License
`swarmauri_toolkit_github` is released under the Apache 2.0 License. See `LICENSE` for full details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, toolkit, github | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"pygithub>=2.4.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:14.661414 | swarmauri_toolkit_github-0.8.3.dev5-py3-none-any.whl | 16,295 | 70/57/679383cf8d43538840d6864624b44e85f8f9c8cc6a9ca5b8f6cb11205c88/swarmauri_toolkit_github-0.8.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | b53224a54688eab1b24ab4ed9ea56fb8 | de898e280302952210e17f18d08330b51a38f7096ac557bfc31993bfb1799464 | 7057679383cf8d43538840d6864624b44e85f8f9c8cc6a9ca5b8f6cb11205c88 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_zapierhook | 0.8.3.dev5 | Zapier Hook Tool | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_zapierhook/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_zapierhook" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_zapierhook/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_zapierhook.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_zapierhook/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_zapierhook" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_zapierhook/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_zapierhook" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_zapierhook/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_zapierhook?label=swarmauri_tool_zapierhook&color=green" alt="PyPI - swarmauri_tool_zapierhook"/></a>
</p>
---
# Swarmauri Tool · Zapier Hook
A Swarmauri tool that triggers Zapier catch webhooks from within agent workflows. Use it to hand off conversation state to Zapier automations—send notifications, update CRMs, open tickets, or kick off custom Zaps with a single function call.
- Accepts JSON payloads as strings and posts them to a Zapier webhook URL.
- Surfaces the Zapier HTTP response (success or failure) in a structured dictionary.
- Built on `requests` so you can extend headers, authentication, or timeout behaviour if required.
## Requirements
- Python 3.10 – 3.13.
- A Zapier webhook URL (copy from Zap setup → **Webhooks by Zapier** → **Catch Hook**). Store it securely (environment variables, secrets manager).
- Dependencies (`requests`, `swarmauri_base`, `swarmauri_standard`, `pydantic`) install automatically with the package.
## Installation
Pick the packaging workflow that fits your project; each command installs dependencies.
**pip**
```bash
pip install swarmauri_tool_zapierhook
```
**Poetry**
```bash
poetry add swarmauri_tool_zapierhook
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_zapierhook
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_zapierhook
```
> Tip: Treat the webhook URL like a secret. Avoid hardcoding it in source control and prefer environment variables.
## Quick Start
```python
import json
import os
from swarmauri_tool_zapierhook import ZapierHookTool
zap_url = os.environ["ZAPIER_WEBHOOK_URL"]
zap_tool = ZapierHookTool(zap_url=zap_url)
payload = json.dumps({
"message": "Hello from Swarmauri!",
"source": "webhook-demo"
})
result = zap_tool(payload)
print(result["zap_response"])
```
`ZapierHookTool` wraps the payload in a JSON object (`{"data": payload}`) before posting, matching the expectations of most Zapier catch hooks.
## Usage Scenarios
### Forward Agent Decisions to Zapier
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_zapierhook import ZapierHookTool
registry = ToolRegistry()
registry.register(ZapierHookTool(zap_url=os.environ["ZAPIER_WEBHOOK_URL"]))
agent = Agent(tool_registry=registry)
message = HumanMessage(content="log a follow-up task for the sales team")
response = agent.run(message)
print(response)
```
The agent can serialize conversation context, send it to Zapier, and continue the dialogue with confirmation details.
### Escalate Incidents From Monitoring Scripts
```python
import json
import os
from swarmauri_tool_zapierhook import ZapierHookTool
zap_tool = ZapierHookTool(zap_url=os.environ["INCIDENT_ZAP_URL"])
alert = {
"service": "payments",
"severity": "critical",
"message": "Latency exceeded threshold"
}
result = zap_tool(json.dumps(alert))
print("Zapier response:", result["zap_response"])
```
Trigger a Zap that files tickets, posts to Slack, or updates status pages when your monitoring detects issues.
### Batch Replay Events
```python
import json
import os
from swarmauri_tool_zapierhook import ZapierHookTool
zap_tool = ZapierHookTool(zap_url=os.environ["EVENT_ZAP_URL"])
with open("events.json") as fh:
events = json.load(fh)
for event in events:
payload = json.dumps(event)
zap_tool(payload)
```
Replay queued events into Zapier when systems come back online.
## Troubleshooting
- **`requests.exceptions.HTTPError`** – Zapier returned a non-200 status (often 401 due to malformed or revoked URLs). Check the webhook URL and payload format.
- **Timeouts or connection errors** – Ensure the environment has outbound internet access and consider wrapping the tool to set explicit timeouts or retries.
- **Zap expects structured JSON** – The tool sends `{"data": payload}`. Adjust your Zap’s “Catch Hook” step or extend the tool if you need different envelope fields.
## License
`swarmauri_tool_zapierhook` is released under the Apache 2.0 License. See `LICENSE` for full details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, zapierhook, zapier, hook | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:02.739167 | swarmauri_tool_zapierhook-0.8.3.dev5.tar.gz | 8,529 | 3a/5f/7434ca4615485f42137a3d4220b34612a0cc88a82ce2ac450f1c70414e1c/swarmauri_tool_zapierhook-0.8.3.dev5.tar.gz | source | sdist | null | false | 4d99ed96dd175030a06c1d2aa4bf5984 | 976ab45d98fa25aca42b7a44752af3ed695bc4c4e320138e27302c6491cb2191 | 3a5f7434ca4615485f42137a3d4220b34612a0cc88a82ce2ac450f1c70414e1c | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_webscraping | 0.9.2.dev4 | Web Scraping Tool for Swarmauri | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_webscraping/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_webscraping" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_webscraping/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_webscraping.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_webscraping/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_webscraping" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_webscraping/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_webscraping" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_webscraping/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_webscraping?label=swarmauri_tool_webscraping&color=green" alt="PyPI - swarmauri_tool_webscraping"/></a>
</p>
---
# Swarmauri Tool · Web Scraping
A Swarmauri-compatible scraper that fetches HTML with `requests`, parses it via BeautifulSoup, and extracts content with CSS selectors. Ideal for lightweight data collection, compliance checks, or enriching agent answers with live webpage snippets.
- Accepts any valid URL and CSS selector; returns joined text content from the matching nodes.
- Handles HTTP/network failures gracefully by surfacing structured error messages.
- Integrates with Swarmauri agents so scraping can be triggered through natural-language prompts.
## Requirements
- Python 3.10 – 3.13.
- `requests` and `beautifulsoup4` (installed automatically with the package).
- Respect site terms of service, robots.txt directives, and rate limits when scraping.
## Installation
Use your preferred packaging workflow—each command installs the dependencies above.
**pip**
```bash
pip install swarmauri_tool_webscraping
```
**Poetry**
```bash
poetry add swarmauri_tool_webscraping
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_webscraping
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_webscraping
```
> Tip: In containerized or restricted environments ensure outbound HTTPS traffic is permitted; `requests` needs network access to reach target sites.
## Quick Start
```python
from swarmauri_tool_webscraping import WebScrapingTool
scraper = WebScrapingTool()
result = scraper(url="https://example.com", selector="h1")
if "extracted_text" in result:
print(result["extracted_text"])
else:
print(result["error"])
```
`extracted_text` concatenates matches separated by newlines. When no elements match the selector, the tool returns an empty string.
## Usage Scenarios
### Monitor Site Copy for Compliance
```python
from swarmauri_tool_webscraping import WebScrapingTool
scraper = WebScrapingTool()
result = scraper(
url="https://status.vendor.com",
selector=".uptime-banner"
)
if "error" in result:
raise RuntimeError(result["error"])
if "maintenance" in result["extracted_text"].lower():
print("Maintenance notice detected – alert the ops team.")
```
### Inject Live Data Into a Swarmauri Agent Response
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_webscraping import WebScrapingTool
registry = ToolRegistry()
registry.register(WebScrapingTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="Check the headline on https://example.com")
response = agent.run(message)
print(response)
```
### Batch Collect Headlines From Multiple Pages
```python
from swarmauri_tool_webscraping import WebScrapingTool
scraper = WebScrapingTool()
urls = [
"https://news.example.com/tech",
"https://news.example.com/business",
]
for url in urls:
result = scraper(url=url, selector="h2.article-title")
print(url)
print(result.get("extracted_text", result.get("error")))
print("---")
```
## Troubleshooting
- **`Request error`** – Network failures, DNS issues, or HTTP 4xx/5xx responses produce `Request error` messages. Verify connectivity, headers, or authentication if required by the site.
- **Empty `extracted_text`** – The selector may not match any nodes. Use browser dev tools to confirm the CSS selector or adjust the parser to target the correct element.
- **SSL certificate problems** – Pass `verify=False` by forking/extending the tool only when you trust the target; otherwise update CA certificates on the host.
## License
`swarmauri_tool_webscraping` is released under the Apache 2.0 License. See `LICENSE` for full details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, webscraping, web, scraping | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"beautifulsoup4>=4.10.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:52:01.659765 | swarmauri_tool_webscraping-0.9.2.dev4-py3-none-any.whl | 9,202 | 93/74/ad0c4baab66964a269e098c80e9a42589db3d4c605fa5c4e357f23aad7e2/swarmauri_tool_webscraping-0.9.2.dev4-py3-none-any.whl | py3 | bdist_wheel | null | false | f6d5364ad04a3bd13a8011b5f14eb1d3 | f2e66e1c0841d743ef6676cefce2fa71ee659d6f783ddb89198be078b42cc263 | 9374ad0c4baab66964a269e098c80e9a42589db3d4c605fa5c4e357f23aad7e2 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_textlength | 0.8.3.dev5 | Text Length Tool for Swarmauri | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_textlength/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_textlength" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_textlength/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_textlength.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_textlength/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_textlength" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_textlength/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_textlength" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_textlength/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_textlength?label=swarmauri_tool_textlength&color=green" alt="PyPI - swarmauri_tool_textlength"/></a>
</p>
---
# Swarmauri Tool · Text Length
A Swarmauri-ready helper that measures text length in characters, words, and sentences using NLTK tokenization. Drop it into content pipelines, moderation bots, or editorial agents to monitor message size and cadence.
- Counts characters (excluding spaces) for quick size checks.
- Uses NLTK tokenizers to calculate word and sentence totals accurately.
- Returns a structured dictionary suitable for logging, analytics, or conversational outputs.
## Requirements
- Python 3.10 – 3.13.
- `nltk` with the `punkt_tab` resource available (downloaded automatically on import).
- Core Swarmauri dependencies (`swarmauri_base`, `swarmauri_standard`, `pydantic`).
## Installation
Pick the packaging tool that fits your workflow; each command installs dependencies.
**pip**
```bash
pip install swarmauri_tool_textlength
```
**Poetry**
```bash
poetry add swarmauri_tool_textlength
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_textlength
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_textlength
```
> Tip: When building containers or offline environments, pre-fetch NLTK data with `python -m nltk.downloader punkt_tab` to avoid runtime downloads.
## Quick Start
```python
from swarmauri_tool_textlength import TextLengthTool
text = "This is a simple test sentence."
length_tool = TextLengthTool()
result = length_tool(text)
print(result)
# {
# 'num_characters': 26,
# 'num_words': 7,
# 'num_sentences': 1
# }
```
## Usage Scenarios
### Enforce Message Length in Moderation Bots
```python
from swarmauri_tool_textlength import TextLengthTool
length_checker = TextLengthTool()
message = """Please keep replies under 50 words so the queue stays manageable."""
metrics = length_checker(message)
if metrics["num_words"] > 50:
raise ValueError("Message too long for moderation queue")
```
### Provide Real-Time Feedback in a Swarmauri Agent
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_textlength import TextLengthTool
registry = ToolRegistry()
registry.register(TextLengthTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="Analyze how long this paragraph is compared to our guideline.")
response = agent.run(message)
print(response)
```
### Batch Audit Documentation for Sentence Length
```python
from pathlib import Path
from swarmauri_tool_textlength import TextLengthTool
length_tool = TextLengthTool()
for doc in Path("docs").rglob("*.md"):
metrics = length_tool(doc.read_text(encoding="utf-8"))
print(f"{doc}: {metrics['num_sentences']} sentences, {metrics['num_words']} words")
```
Scan an entire documentation set to identify sprawling sections or under-documented topics.
## Troubleshooting
- **`LookupError: Resource punkt_tab not found`** – Run `python -m nltk.downloader punkt_tab` ahead of time, especially in air-gapped deployments.
- **Unexpected character counts** – The tool excludes spaces; adjust the implementation if you need raw length including whitespace.
- **Non-English text** – NLTK’s default tokenizers target English. Swap in language-specific tokenizers if needed.
## License
`swarmauri_tool_textlength` is released under the Apache 2.0 License. See `LICENSE` for full details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, textlength, text, length | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nltk>=3.9.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:58.667623 | swarmauri_tool_textlength-0.8.3.dev5.tar.gz | 8,038 | d7/c1/6ae57fa482285a95b98f03919aa7949545028ecd1b8f5b4377e1f56f2ba9/swarmauri_tool_textlength-0.8.3.dev5.tar.gz | source | sdist | null | false | 09838b6ef71b840cd5ed632566270615 | b1217476b9d29533ee7e8a9780506f6f3220fc92b4244044ccf9dcd6301dac88 | d7c16ae57fa482285a95b98f03919aa7949545028ecd1b8f5b4377e1f56f2ba9 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_smogindex | 0.9.3.dev5 | Swarmauri Smog Index Tool. |
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_smogindex/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_smogindex" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_smogindex/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_smogindex.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_smogindex/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_smogindex" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_smogindex/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_smogindex" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_smogindex/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_smogindex?label=swarmauri_tool_smogindex&color=green" alt="PyPI - swarmauri_tool_smogindex"/></a>
</p>
---
# Swarmauri Tool Smog Index
A tool for calculating the SMOG (Simple Measure of Gobbledygook) Index of text, which estimates the years of education needed to understand a piece of written material.
## Installation
```bash
pip install swarmauri_tool_smogindex
```
## Usage
```python
from swarmauri.tools.SMOGIndexTool import SMOGIndexTool
# Initialize the tool
tool = SMOGIndexTool()
# Analyze text
text = "This is a sample text with some complex sentences and polysyllabic words to test the SMOG Index calculation."
result = tool(text)
# Get the SMOG index
smog_index = result['smog_index']
print(f"SMOG Index: {smog_index}") # Output: SMOG Index: 8.5
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, smogindex, smog, index | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nltk>=3.9.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard",
"transformers>=4.45.0"
] | [] | [] | [] | [] | 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-18T09:51:57.640678 | swarmauri_tool_smogindex-0.9.3.dev5.tar.gz | 7,193 | db/60/c18dd376de206954fbe3103a8a6b61a2b73827bdda6b80b5c15100fbc828/swarmauri_tool_smogindex-0.9.3.dev5.tar.gz | source | sdist | null | false | 9a4f9f3c0883a5e11eed793d189b09dc | 8fdd828e5e40a829166b1660a35a224ee996353200fdeef4d1a66827039369d3 | db60c18dd376de206954fbe3103a8a6b61a2b73827bdda6b80b5c15100fbc828 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.1 | leaf-diag | 0.1.4 | A diagnostic tool for parsing DroneLeaf controller and PX4 logs | # leaf-diag
A comprehensive diagnostic tool for analyzing and synchronizing flight logs from drone systems, supporting both PX4 ULog and ROS bag file formats with advanced correlation-based time synchronization.
## Overview
`leaf-diag` is designed to process and analyze flight log data from drone systems, providing time-synchronized data analysis, visualization, and export capabilities. The tool excels at:
**Core Features:**
- **Time Synchronization**: Advanced correlation-based algorithm to automatically synchronize PX4 ULog and ROS bag data
- **Multi-format Support**: Native support for PX4 ULog files and ROS bag files
- **Signal Processing**: Handles both single-instance and multi-instance sensor data
- **Data Transformation**: Automatic coordinate frame transformations between PX4 (NED) and DroneLeaf coordinate systems
- **Robust Correlation**: NaN-aware correlation calculations with negative offset support
**Supported Flight Types:**
- Indoor flights with optical flow and distance sensors
- Outdoor flights with GPS, magnetometer, and optical flow
- Mixed sensor configurations with flexible sensor enablement
**Data Export Formats:**
- Combined ROS bag files with synchronized timestamps
- CSV exports for data analysis
- Comprehensive visualization charts
- Correlation analysis plots
## Setup Instructions
### Prerequisites
- Python 3.9 - 3.11
- ROS environment (for bag file handling)
- HEAR-CLI tool
### Installation
1. Install PDM (Python dependency manager) using HEAR-CLI:
```bash
hear-cli local_machine run_program --p pdm_install
```
2. Clone the repository:
```bash
git clone https://github.com/your-organization/leaf-diag.git
cd leaf-diag
```
3. Install dependencies using PDM:
```bash
pdm install
```
## Usage
### Basic Workflow
1. **Configure Your Analysis**: Define log processing parameters
2. **Initialize Exporter**: Choose between indoor/outdoor analysis modes
3. **Extract and Synchronize**: Process data with automatic time alignment
4. **Export Results**: Generate synchronized outputs and visualizations
### Configuration Parameters
Each log analysis requires a configuration dictionary with the following parameters:
- `data_dir`: Directory containing input log files
- `output_dir`: Directory for analysis results and outputs
- `bag_path`: ROS bag filename (optional, can be `None`)
- `ulg_path`: PX4 ULog filename (required)
- `single_instance`: Boolean flag for single vs. multi-instance processing
- `sensor_config`: Dictionary specifying available sensors (for outdoor flights)
### Exporter Classes
**UlogExporterOutdoor**: For outdoor flights with GPS and optional optical flow
- Supports GPS position and velocity
- Handles GPS accuracy metrics and innovation ratios
- Processes magnetometer data for heading estimation
- Configurable sensor enablement
**UlogExporterIndoor**: For indoor flights using optical flow and distance sensors
- Optimized for non-GPS environments
- Focuses on optical flow velocity estimation
- Processes distance sensor data for altitude
### Example Usage
**Complete Analysis Example:**
```python
import os
from leaf_diag.ulog_export import UlogExporterOutdoor
# Configuration for outdoor flight with GPS
log_config = {
"data_dir": "calibration_tests/CUAV_C-RTK2HP/Log2",
"output_dir": "calibration_tests/CUAV_C-RTK2HP/output_Log2",
"ulg_path": "log_2_2025-6-15-14-30-24.ulg",
"bag_path": "first_half.bag", # Optional: set to None if not available
"single_instance": True,
"sensor_config": {
"gps": True,
"optical_flow": True,
}
}
# Construct full paths
data_dir = log_config["data_dir"]
bag_path = os.path.join(data_dir, log_config["bag_path"]) if log_config["bag_path"] else None
ulg_path = os.path.join(data_dir, log_config["ulg_path"])
# Initialize exporter
exporter = UlogExporterOutdoor(
rosbag_path=bag_path,
ulog_path=ulg_path,
output_dir=log_config["output_dir"],
single_instance=log_config["single_instance"],
sensor_config=log_config["sensor_config"]
)
# Extract and synchronize data (creates correlation plots)
exporter.extract_all_data(plot_correlation=True)
# Generate combined output files
exporter.create_combined_ulog(
output_dir=log_config["output_dir"],
write_csv=True, # Export CSV files
write_bag=True # Create combined ROS bag
)
# Create visualization charts
exporter.create_charts("charts")
```
**Indoor Flight Example:**
```python
from leaf_diag.ulog_export import UlogExporterIndoor
# Indoor flight configuration (no GPS)
indoor_config = {
"data_dir": "indoor_tests/flight_01",
"output_dir": "indoor_tests/output_flight_01",
"ulg_path": "indoor_log_01.ulg",
"bag_path": None, # No ROS bag available
"single_instance": True
}
# Process indoor flight data
exporter = UlogExporterIndoor(
rosbag_path=None,
ulog_path=os.path.join(indoor_config["data_dir"], indoor_config["ulg_path"]),
output_dir=indoor_config["output_dir"],
single_instance=indoor_config["single_instance"]
)
exporter.extract_all_data(plot_correlation=False) # No ROS bag to correlate
exporter.create_combined_ulog(indoor_config["output_dir"])
```
**Sensor Configuration Options:**
```python
# Full sensor configuration for outdoor flights
sensor_config = {
"gps": True, # Enable GPS position/velocity processing
"optical_flow": True, # Enable optical flow velocity estimation
}
# GPS-only configuration
sensor_config = {
"gps": True,
"optical_flow": False,
}
# Minimal configuration (ULog data only)
sensor_config = {
"gps": False,
"optical_flow": False,
}
```
### Key Methods
**extract_all_data(plot_correlation=False)**
- Loads and processes both ULog and ROS bag data
- Performs automatic time synchronization using correlation analysis
- Applies coordinate frame transformations
- Generates correlation plots if `plot_correlation=True`
**create_combined_ulog(output_dir, write_csv=True, write_bag=True)**
- Creates synchronized combined output files
- Returns bytes of the combined ROS bag for programmatic use
- Optionally writes CSV files and ROS bag to disk
**create_charts(output_dir="charts")**
- Generates comprehensive visualization plots for all processed signals
- Creates separate charts for each data type and sensor
## Advanced Features
### Time Synchronization Algorithm
`leaf-diag` uses an advanced correlation-based synchronization algorithm that:
- **Handles Negative Offsets**: Can synchronize signals where one starts before the other
- **NaN-Aware Processing**: Robust handling of missing data points in correlation calculations
- **Multi-dimensional Correlation**: Supports correlation of vector signals (position, velocity, etc.)
- **Overlap Analysis**: Evaluates signal overlap quality and filters correlations by minimum overlap thresholds
- **Automatic Signal Type Detection**: Determines which signal is shorter/longer for optimal alignment
### Coordinate Frame Transformations
The tool automatically handles coordinate frame conversions:
- **PX4 to DroneLeaf**: Transforms from NED (North-East-Down) to DroneLeaf coordinate system
- **GPS to Local**: Converts GPS coordinates to local position with configurable calibration offsets
- **Quaternion to Euler**: Automatic conversion of attitude quaternions to roll/pitch/yaw angles
- **Optical Flow Integration**: Combines optical flow with distance sensors for velocity estimation
### Multi-Instance Data Handling
For sensors with multiple instances (e.g., multiple accelerometers):
- **Automatic Detection**: Scans ULog files to detect number of sensor instances
- **Independent Processing**: Each instance is processed and synchronized separately
- **Configurable Output**: Results can be exported per-instance or aggregated
## Output Files and Structure
The analysis generates a comprehensive set of outputs in your specified `output_dir`:
### 1. Combined ROS Bag File
- **File**: `combined_data.bag` (or your specified filename)
- **Content**: Time-synchronized data from both ULog and ROS bag sources
- **Topics**: Organized under `/px4/` and `/ros/` namespaces for easy identification
- **Format**: Standard ROS bag format compatible with analysis tools
### 2. CSV Data Exports
- **px4_position.csv**: Local position data (x, y, z coordinates)
- **px4_velocity.csv**: Velocity vectors
- **px4_orientation.csv**: Euler angles (roll, pitch, yaw)
- **px4_acceleration.csv**: Acceleration measurements
- **ros_*.csv**: Corresponding ROS data (if available)
- **Multi-instance files**: Separate CSV files for each sensor instance
### 3. Visualization Charts
- **position_comparison.png**: Position trajectories comparison
- **orientation_comparison.png**: Attitude angle plots
- **Signal plots**: Individual charts for each processed signal type
- **Multi-dimensional plots**: Separate subplots for x, y, z components
### 4. Correlation Analysis
- **[signal]_correlation.png**: Cross-correlation plots showing time offset analysis
- **[signal]_overlap.png**: Signal overlap analysis
- **[signal]_signals.png**: Time-aligned signal comparison plots
### 5. Metadata and Configuration
- **metadata.json**: Analysis metadata including timestamps and version info
- **Processing logs**: Detailed logs of the synchronization process
### Directory Structure Example
```
output_directory/
├── combined_data.bag # Main synchronized output
├── csv/ # CSV exports
│ ├── px4_position.csv
│ ├── px4_orientation.csv
│ ├── ros_position.csv
│ └── ...
├── charts/ # Visualization plots
│ ├── position_comparison.png
│ ├── orientation_comparison.png
│ └── ...
├── acceleration_correlation.png # Correlation analysis
├── acceleration_overlap.png # Overlap analysis
├── acceleration_signals.png # Signal alignment
└── metadata.json # Analysis metadata
```
## Running Analysis
### Command Line Execution
Run the analysis using PDM:
```bash
# Run with main.py configuration
pdm run python main.py
# Run with custom script
pdm run python your_analysis_script.py
```
### Batch Processing
For processing multiple logs, see the examples in `main_adv.py` which demonstrates batch processing of multiple flight logs with different configurations.
### Testing
Run the test suite to verify functionality:
```bash
# Run all tests
pdm run pytest
# Run specific test modules
pdm run pytest tests/test_signal.py
pdm run pytest tests/test_sync.py
```
> [!NOTE]
> The `rosbag_path` parameter is optional and can be set to `None` if no ROS bag is available. The tool will still process ULog data and generate outputs.
> [!IMPORTANT]
> Use `UlogExporterIndoor` for indoor flights and `UlogExporterOutdoor` for outdoor flights. The classes have different sensor processing capabilities optimized for their respective environments.
## Visualization and Analysis
### PlotJuggler Integration
View the combined bag files with PlotJuggler for interactive analysis:
```bash
./scripts/launch_plotjuggler.sh output_directory
```
### Data Analysis Tips
1. **Correlation Quality**: Check correlation plots to verify synchronization quality
2. **Signal Overlap**: Ensure sufficient overlap between signals for reliable correlation
3. **Coordinate Frames**: Be aware that position data is automatically transformed to DroneLeaf coordinates
4. **Multi-Instance Data**: Use instance-specific topics when analyzing sensor arrays
## Troubleshooting
### Common Issues
**Low Correlation Values**
- Check that both log files cover overlapping time periods
- Verify that the signals being correlated are actually related (e.g., same sensor type)
- Consider adjusting correlation parameters if needed
**Missing Data**
- Ensure ULog file contains the expected message types
- Check that ROS bag topics match expected naming conventions
- Verify file paths and permissions
**Synchronization Problems**
- Review correlation plots to diagnose sync issues
- Check for sufficient signal overlap in the overlap analysis plots
- Consider if negative time offsets are expected for your data
### Performance Considerations
- Large log files may require significant processing time for correlation analysis
- Consider using `single_instance=True` for faster processing when appropriate
- Correlation plots generation can be disabled for faster batch processing
## Developer Guidelines
### Extending Functionality
The modular design allows easy extension for new sensor types or data formats:
1. **New Signal Types**: Inherit from `UlogSignal` or `RosSignal` base classes
2. **Custom Transformations**: Add coordinate frame transformations in `data_transform.py`
3. **Additional Exporters**: Create specialized exporters for new flight types
### ULog Topic Reference
For a comprehensive list of supported ULog topics and message structures, see [ulog_directory.json](ulog_directory.json).
### Code Structure
- `data_loader.py`: Signal extraction and base classes
- `data_sync.py`: Time synchronization algorithms
- `data_transform.py`: Coordinate frame transformations
- `ulog_export.py`: Main export and processing classes
- `ros_utils.py`: ROS bag handling utilities | text/markdown | null | Khalil Al Handawi <khalil.alhandawi@mail.mcgill.ca> | null | null | MIT | null | [] | [] | null | null | <3.12,>=3.9 | [] | [] | [] | [
"bagpy>=0.5",
"px4tools>=0.9.6",
"tqdm>=4.67.1",
"scipy>=1.9.3",
"numpy>=1.24.4",
"pydantic>=2.12.5"
] | [] | [] | [] | [] | twine/6.1.0 CPython/3.13.7 | 2026-02-18T09:51:57.114915 | leaf_diag-0.1.4.tar.gz | 38,381 | 07/15/9fd2811c4917d5eb9cae6b8070910d9d7f758e222ad9c0524b80438c5084/leaf_diag-0.1.4.tar.gz | source | sdist | null | false | b41592b94be4531c4f72067f0f420b4d | 5a7e6f5b1bfd694a30ed5b2cb7350f347eae69295564122e4525c6b26d660f87 | 07159fd2811c4917d5eb9cae6b8070910d9d7f758e222ad9c0524b80438c5084 | null | [] | 230 |
2.4 | picamzero | 1.0.3 | A library to make it easy for beginners to use the Raspberry Pi camera | # `picamzero`
`picamzero` is a Python 3 library designed to allow beginners to control a Raspberry Pi camera with Python.
## Install
1. Open a terminal window on your Raspberry Pi.
2. Run these commands (one at a time) to install `picamzero`:
```
sudo apt update
sudo apt install python3-picamzero
```
## Documentation
Full, beginner-friendly documentation is provided at
[[https://raspberrypifoundation.github.io/picamzero](https://raspberrypifoundation.github.io/picamzero)](https://raspberrypifoundation.github.io/picamzero/).
| text/markdown | null | Raspberry Pi Foundation <learning@raspberrypi.org> | null | null | MIT License
Copyright (c) 2024 Raspberry Pi Foundation
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. | null | [] | [] | null | null | >=3.11 | [] | [] | [] | [
"opencv-python-headless",
"picamera2"
] | [] | [] | [] | [] | twine/6.2.0 CPython/3.9.6 | 2026-02-18T09:51:46.295404 | picamzero-1.0.3.tar.gz | 4,452,283 | e4/85/4b5776ae2ff05b6af0f46e1a884b83417869cbd81a4dd6045a8a993cf8e3/picamzero-1.0.3.tar.gz | source | sdist | null | false | 713b23f7f59c27ea0b4cac7b5f102dcd | b6e873a7e2e633ce8ee939e0d344c4f5a9a3c29da7b73e304a58ebef4a8dfb87 | e4854b5776ae2ff05b6af0f46e1a884b83417869cbd81a4dd6045a8a993cf8e3 | null | [
"LICENSE"
] | 252 |
2.4 | swarmauri_tool_sentimentanalysis | 0.8.2.dev4 | Sentiment Analysis Tool |
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_sentimentanalysis/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_sentimentanalysis" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_sentimentanalysis/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_sentimentanalysis.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_sentimentanalysis/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_sentimentanalysis" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_sentimentanalysis/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_sentimentanalysis" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_sentimentanalysis/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_sentimentanalysis?label=swarmauri_tool_sentimentanalysis&color=green" alt="PyPI - swarmauri_tool_sentimentanalysis"/></a>
</p>
---
# Swarmauri Tool Sentimentanalysis
A tool for analyzing the sentiment of text using Hugging Face's transformers library. This tool provides simple sentiment analysis capabilities, classifying text as POSITIVE, NEGATIVE, or NEUTRAL.
## Installation
```bash
pip install swarmauri_tool_sentimentanalysis
```
## Usage
Here's a basic example of how to use the Sentiment Analysis Tool:
```python
from swarmauri.tools.SentimentAnalysisTool import SentimentAnalysisTool
# Initialize the tool
tool = SentimentAnalysisTool()
# Analyze sentiment
result = tool("I love this product!")
print(result) # {'sentiment': 'POSITIVE'}
# Another example
result = tool("This product is okay.")
print(result) # {'sentiment': 'NEUTRAL'}
```
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, sentimentanalysis, sentiment, analysis | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard",
"tensorflow>=2.16.2",
"tf-keras",
"torch>=2.6.0",
"transformers>=4.49.0"
] | [] | [] | [] | [] | 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-18T09:51:45.410275 | swarmauri_tool_sentimentanalysis-0.8.2.dev4-py3-none-any.whl | 8,048 | dd/35/e48938c5b4d64c9e557435e61dcb39fe4452a2d53d153ce124cc9de91bf1/swarmauri_tool_sentimentanalysis-0.8.2.dev4-py3-none-any.whl | py3 | bdist_wheel | null | false | cd873a44df0c9c47b3003ac05c256e0e | 1bdcfad399e957d4da3569fe46c3154d7408deddd397dd981a2a97c15ba8236a | dd35e48938c5b4d64c9e557435e61dcb39fe4452a2d53d153ce124cc9de91bf1 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_searchword | 0.3.3.dev5 | A tool for searching a specific word or phrase in a file. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_searchword/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_searchword" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_searchword/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_searchword.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_searchword/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_searchword" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_searchword/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_searchword" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_searchword/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_searchword?label=swarmauri_tool_searchword&color=green" alt="PyPI - swarmauri_tool_searchword"/></a>
</p>
---
# Swarmauri Tool · Search Word
A Swarmauri utility for counting case-insensitive word or phrase occurrences in text files. The tool highlights matching lines and returns both the count and the decorated text so you can surface findings in agent conversations or CI logs.
- Accepts any UTF-8 text file and performs case-insensitive matching.
- Preserves surrounding context by returning the full line with ANSI highlighting (red) when a match is found.
- Ships as a Swarmauri tool, so it can be registered alongside other agent capabilities.
## Requirements
- Python 3.10 – 3.13.
- No external libraries beyond the core Swarmauri dependencies (`swarmauri_base`, `swarmauri_standard`, `pydantic`).
## Installation
Choose the installer that matches your workflow; each command collects the required dependencies.
**pip**
```bash
pip install swarmauri_tool_searchword
```
**Poetry**
```bash
poetry add swarmauri_tool_searchword
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_searchword
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_searchword
```
> Tip: The tool reads files from disk, so ensure the executing process has permission to access the target path.
## Quick Start
```python
from swarmauri_tool_searchword import SearchWordTool
search = SearchWordTool()
result = search(file_path="docs/README.md", search_word="swarmauri")
print(result["count"])
# e.g., 5
for line in result["lines"]:
print(line)
```
Matching lines are wrapped with ANSI escape codes (red foreground). When piping to logs or terminals that render ANSI, matches stand out immediately.
## Usage Scenarios
### Enforce Terminology in CI Pipelines
```python
from pathlib import Path
from swarmauri_tool_searchword import SearchWordTool
search = SearchWordTool()
for file in Path("docs").rglob("*.md"):
result = search(file_path=str(file), search_word="utilize")
if result["count"] > 0:
raise SystemExit(f"Forbidden term found in {file}: {result['count']} occurrences")
```
Stop merges when banned words or phrases appear in documentation.
### Provide Explanations in an Agent Response
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_searchword import SearchWordTool
registry = ToolRegistry()
registry.register(SearchWordTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="How many times do we mention 'latency' in docs/overview.txt?")
response = agent.run(message)
print(response)
```
Agents can report both the count and the highlighted context back to the user.
### Audit Configuration Files for Secrets
```python
from swarmauri_tool_searchword import SearchWordTool
search = SearchWordTool()
config_files = [".env", "config/production.ini"]
for path in config_files:
result = search(file_path=path, search_word="api_key")
if result["count"]:
print(f"Potential secret reference in {path}: {result['count']} matches")
```
Quickly scan multiple configuration files when performing security reviews.
## Troubleshooting
- **`FileNotFoundError`** – Confirm the path is correct and accessible. Relative paths are resolved from the current working directory of the process invoking the tool.
- **`Invalid input`** – The tool only accepts string file paths and search terms. Validate arguments if they originate from user prompts.
- **ANSI escape codes in output** – If your consumer cannot render ANSI, strip the escape sequences before displaying (e.g., with `re.sub(r'\x1b\[[0-9;]*m', '', line)`).
## License
`swarmauri_tool_searchword` is released under the Apache 2.0 License. See `LICENSE` for full details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | search, tool, word, phrase, file, highlight, swarmauri, searchword, searching, specific | [
"License :: OSI Approved :: Apache Software License",
"Natural Language :: English",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Development Status :: 3 - Alpha",
"Programming Language :: Python :: 3.12",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"pydantic",
"requests",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:38.704712 | swarmauri_tool_searchword-0.3.3.dev5.tar.gz | 8,534 | 47/42/012c3b8392344eca8a8e4cf0c51fe1a2ad4cd457baa7c5de316dc423b536/swarmauri_tool_searchword-0.3.3.dev5.tar.gz | source | sdist | null | false | 59eca19c30a90c8875c7a2e2c3df7ee6 | 7bba4066e950034a2bfba19b160b156471310364ec0aed2bfe5b7601ee32fb79 | 4742012c3b8392344eca8a8e4cf0c51fe1a2ad4cd457baa7c5de316dc423b536 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_psutil | 0.9.3.dev5 | Swarmauri Psutil Tool. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_psutil/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_psutil" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_psutil/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_psutil.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_psutil/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_psutil" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_psutil/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_psutil" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_psutil/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_psutil?label=swarmauri_tool_psutil&color=green" alt="PyPI - swarmauri_tool_psutil"/></a>
</p>
---
# Swarmauri Tool · psutil
A Swarmauri-compatible system inspection tool powered by `psutil`. Use it to surface CPU, memory, disk, network, and sensor telemetry inside agents, observability workflows, or health checks.
- Wraps rich `psutil` APIs behind a single callable interface.
- Returns structured dictionaries that mirror psutil's native data models (converted to plain Python objects for JSON serialization).
- Handles common permission gaps gracefully (e.g., network connections, sensors) so calls do not crash automation.
## Requirements
- Python 3.10 – 3.13.
- `psutil` installed (pulled automatically with the package).
- Optional platform support: some sensor endpoints require root/admin privileges or may not exist on virtualized hosts.
## Installation
Select the installer that matches your environment; each command resolves transitive dependencies.
**pip**
```bash
pip install swarmauri_tool_psutil
```
**Poetry**
```bash
poetry add swarmauri_tool_psutil
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_psutil
# or install directly into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_psutil
```
> Tip: psutil needs native build tooling on some platforms (musl-based containers, Alpine). Install the OS-level prerequisites before running the package install command.
## Quick Start
```python
from pprint import pprint
from swarmauri_tool_psutil import PsutilTool
psutil_tool = PsutilTool()
cpu = psutil_tool("cpu")
mem = psutil_tool("memory")
print("CPU summary:")
pprint(cpu)
print("Memory summary:")
pprint(mem)
```
Each call returns a dictionary keyed by metrics families (e.g., `cpu_times`, `virtual_memory`). Use only the sections you need in downstream automations.
## Usage Scenarios
### Build a Lightweight Health Endpoint
```python
from fastapi import FastAPI
from swarmauri_tool_psutil import PsutilTool
app = FastAPI()
ps_tool = PsutilTool()
@app.get("/health/system")
def system_health():
return {
"cpu": ps_tool("cpu"),
"memory": ps_tool("memory"),
"disk": ps_tool("disk"),
}
```
Expose system metrics to dashboards or probes without wiring psutil manually.
### Enrich Swarmauri Agent Responses With Telemetry
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_psutil import PsutilTool
registry = ToolRegistry()
registry.register(PsutilTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="report system cpu load and memory usage")
response = agent.run(message)
print(response)
```
Register the tool alongside other Swarmauri capabilities so agents can answer operational questions on demand.
### Archive High-Usage Events for Later Analysis
```python
import json
import time
from pathlib import Path
from swarmauri_tool_psutil import PsutilTool
ps_tool = PsutilTool()
log_dir = Path("telemetry_logs")
log_dir.mkdir(exist_ok=True)
while True:
snapshot = {
"ts": time.time(),
"cpu": ps_tool("cpu"),
"memory": ps_tool("memory"),
"network": ps_tool("network"),
}
(log_dir / f"snapshot-{int(snapshot['ts'])}.json").write_text(
json.dumps(snapshot, indent=2)
)
time.sleep(60)
```
Capture periodic snapshots that can be loaded into notebooks, dashboards, or anomaly detection jobs.
## Troubleshooting
- **`ValueError: Invalid info_type`** – Only `"cpu"`, `"memory"`, `"disk"`, `"network"`, and `"sensors"` are supported. Validate user input before calling the tool.
- **`Permission denied` retrieving connections/sensors** – Run with elevated privileges or filter out those sections. The tool returns a descriptive string when it cannot access the data.
- **`psutil.AccessDenied` on containerized hosts** – Grant the container additional capabilities (e.g., `SYS_PTRACE`) or restrict to metrics that do not require elevated rights.
## License
`swarmauri_tool_psutil` is released under the Apache 2.0 License. See `LICENSE` for details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, psutil | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"psutil>=6.1.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:37.731802 | swarmauri_tool_psutil-0.9.3.dev5-py3-none-any.whl | 10,203 | 36/0d/a86627af02f22b43a26231c64d1917939df3465e87f82140f7782a8f6cf8/swarmauri_tool_psutil-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | 9b8507f5f106dfd51b3e49fce68ada32 | abad45bae860199a5e95605806229bf60aea7e0855471b72d3179e14ce4aea3a | 360da86627af02f22b43a26231c64d1917939df3465e87f82140f7782a8f6cf8 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_sentencecomplexity | 0.9.3.dev5 | This repository includes an example of a First Class Swarmauri Example. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_sentencecomplexity/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_sentencecomplexity" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_sentencecomplexity/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_sentencecomplexity.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_sentencecomplexity/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_sentencecomplexity" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_sentencecomplexity/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_sentencecomplexity" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_sentencecomplexity/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_sentencecomplexity?label=swarmauri_tool_sentencecomplexity&color=green" alt="PyPI - swarmauri_tool_sentencecomplexity"/></a>
</p>
---
# Swarmauri Tool · Sentence Complexity
A Swarmauri NLP tool that evaluates sentence complexity by measuring average sentence length and estimating clause counts. Use it to monitor writing style, enforce readability requirements, or trigger editorial suggestions in agents.
- Tokenizes text with NLTK to compute sentence and word counts.
- Approximates clause density via punctuation and coordinating/subordinating conjunctions.
- Returns structured metrics suitable for analytics dashboards or conversational feedback.
## Requirements
- Python 3.10 – 3.13.
- `nltk` (downloads the `punkt_tab` tokenizer data on first import).
- Core Swarmauri dependencies (`swarmauri_base`, `swarmauri_standard`, `pydantic`).
## Installation
Choose the packaging workflow that matches your project; each command resolves the dependencies.
**pip**
```bash
pip install swarmauri_tool_sentencecomplexity
```
**Poetry**
```bash
poetry add swarmauri_tool_sentencecomplexity
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_sentencecomplexity
# or install into the active environment without modifying pyproject.toml
uv pip install swarmauri_tool_sentencecomplexity
```
> Tip: Pre-download the NLTK tokenizer resources in deployment images (`python -m nltk.downloader punkt_tab`) to avoid runtime network calls.
## Quick Start
```python
from swarmauri_tool_sentencecomplexity import SentenceComplexityTool
text = "This is a simple sentence. This is another sentence, with a clause."
complexity_tool = SentenceComplexityTool()
result = complexity_tool(text)
print(result)
# {
# 'average_sentence_length': 7.5,
# 'average_clauses_per_sentence': 1.5
# }
```
The tool raises `ValueError` when the input text is empty or whitespace.
## Usage Scenarios
### Flag Long Sentences During Editing
```python
from swarmauri_tool_sentencecomplexity import SentenceComplexityTool
complexity = SentenceComplexityTool()
article = Path("drafts/whitepaper.txt").read_text(encoding="utf-8")
metrics = complexity(article)
if metrics["average_sentence_length"] > 25:
print("Consider splitting long sentences to improve readability.")
```
### Integrate With a Swarmauri Agent for Style Coaching
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_sentencecomplexity import SentenceComplexityTool
registry = ToolRegistry()
registry.register(SentenceComplexityTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="Analyze the complexity of: 'While the system scales, it may introduce latency delays.'")
response = agent.run(message)
print(response)
```
### Compare Versions of a Document Over Time
```python
from swarmauri_tool_sentencecomplexity import SentenceComplexityTool
complexity = SentenceComplexityTool()
versions = {
"draft": open("draft.txt").read(),
"final": open("final.txt").read(),
}
for label, text in versions.items():
metrics = complexity(text)
print(f"{label}: {metrics['average_sentence_length']:.1f} words, {metrics['average_clauses_per_sentence']:.2f} clauses")
```
Track whether edits are making the writing clearer or more complex.
## Troubleshooting
- **`LookupError: Resource punkt_tab not found`** – Run `python -m nltk.downloader punkt_tab` before executing the tool, especially in offline environments.
- **Low clause counts for technical prose** – The heuristic relies on commas/semicolons and common conjunctions; adjust or extend the tool if you need domain-specific parsing.
- **Non-English text** – Tokenization models are optimized for English. Supply language-appropriate tokenizers before using the tool for other languages.
## License
`swarmauri_tool_sentencecomplexity` is released under the Apache 2.0 License. See `LICENSE` for details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, sentencecomplexity, repository, includes, example, first, class | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nltk>=3.9.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:35.743164 | swarmauri_tool_sentencecomplexity-0.9.3.dev5-py3-none-any.whl | 9,420 | 71/11/5eea66252dc28116d3f1b1059b3002af6c62838955d1486a4c769b3cc466/swarmauri_tool_sentencecomplexity-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | c9cbc32dd0b1ab470849042911ed0bdb | 01f03193d8a719447f8828f80df3c64a113251f3f4525469f03c9ebd2f99176e | 71115eea66252dc28116d3f1b1059b3002af6c62838955d1486a4c769b3cc466 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_qrcodegenerator | 0.9.3.dev5 | Swarmauri QR Code Generator Tool. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_qrcodegenerator/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_qrcodegenerator" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_qrcodegenerator/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_qrcodegenerator.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_qrcodegenerator/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_qrcodegenerator" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_qrcodegenerator/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_qrcodegenerator" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_qrcodegenerator/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_qrcodegenerator?label=swarmauri_tool_qrcodegenerator&color=green" alt="PyPI - swarmauri_tool_qrcodegenerator"/></a>
</p>
---
# Swarmauri Tool · QR Code Generator
A Swarmauri tool that converts text payloads into QR codes and returns the image data as a Base64 string. Plug it into conversational agents, marketing workflows, or automation scripts that need scannable hand-offs (URLs, Wi-Fi credentials, one-time tokens, etc.).
- Backed by `qrcode`/Pillow to produce standards-compliant QR codes.
- Outputs Base64 so responses can be embedded directly in JSON, HTML, or rich chat messages.
- Exposed through the standard Swarmauri tool interface for drop-in registration alongside other capabilities.
## Requirements
- Python 3.10 – 3.13.
- `qrcode` (installs with its Pillow dependency) and Swarmauri base packages (`swarmauri_base`, `swarmauri_standard`, `pydantic`).
- Optional: downstream consumers often decode the Base64 string using Pillow or write it to disk; ensure those environments can handle binary data.
## Installation
Choose the tooling that matches your project; each command resolves transitive dependencies.
**pip**
```bash
pip install swarmauri_tool_qrcodegenerator
```
**Poetry**
```bash
poetry add swarmauri_tool_qrcodegenerator
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_qrcodegenerator
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_qrcodegenerator
```
> Tip: Pillow requires native image libraries on some Linux distributions (e.g., `libjpeg`, `zlib`). Install OS packages before running the commands above in minimal containers.
## Quick Start
```python
import base64
from swarmauri_tool_qrcodegenerator import QrCodeGeneratorTool
qr_tool = QrCodeGeneratorTool()
result = qr_tool("https://docs.swarmauri.ai")
image_b64 = result["image_b64"]
with open("docs-qrcode.png", "wb") as f:
f.write(base64.b64decode(image_b64))
```
The output image uses the tool's default QR code settings (`version=1`, low error correction, black modules on white background). Adjust presentation after decoding if you need different colors or scaling.
## Usage Scenarios
### Embed QR Codes in Agent Responses
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_qrcodegenerator import QrCodeGeneratorTool
registry = ToolRegistry()
registry.register(QrCodeGeneratorTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="Create a QR code for https://status.mycompany.com")
response = agent.run(message)
print(response)
```
Agents can attach the Base64 image to chat payloads so end users scan the code without additional steps.
### Publish Dynamic Event Badges
```python
import base64
from pathlib import Path
from swarmauri_tool_qrcodegenerator import QrCodeGeneratorTool
qr_tool = QrCodeGeneratorTool()
attendees = {
"alice": "ticket:EVT-001-A1B2",
"bob": "ticket:EVT-002-B3C4",
}
badges_dir = Path("badges")
badges_dir.mkdir(exist_ok=True)
for name, token in attendees.items():
b64_img = qr_tool(token)["image_b64"]
(badges_dir / f"{name}.png").write_bytes(base64.b64decode(b64_img))
```
Generate per-attendee QR codes that scanners can translate into ticket tokens at check-in.
### Serve Codes Over HTTP
```python
import base64
from fastapi import FastAPI, Response
from swarmauri_tool_qrcodegenerator import QrCodeGeneratorTool
app = FastAPI()
qr_tool = QrCodeGeneratorTool()
@app.get("/qr")
def qr_endpoint(data: str):
result = qr_tool(data)
png_bytes = base64.b64decode(result["image_b64"])
return Response(content=png_bytes, media_type="image/png")
```
Expose an API that transforms arbitrary data into QR codes your front-end can display.
## Troubleshooting
- **Blank or unreadable codes** – Confirm the Base64 string is decoded to a PNG (`base64.b64decode(...)`). Avoid writing the raw Base64 text directly to file.
- **Binary dependency errors (Pillow)** – Install platform-specific libraries (`apt-get install libjpeg-dev zlib1g-dev`, etc.) before installing the package, especially in slim containers.
- **Large payloads** – Version 1 QR codes have size constraints (~17 alphanumeric characters). Fork the tool or extend it to allow larger versions if you need to encode lengthy data.
## License
`swarmauri_tool_qrcodegenerator` is released under the Apache 2.0 License. See `LICENSE` for details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, qrcodegenerator, code, generator | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"qrcode>=7.3.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:35.325033 | swarmauri_tool_qrcodegenerator-0.9.3.dev5.tar.gz | 8,453 | f8/30/dfa47090677b5ee5e1846e1f31e739a3db3ec18b0c7af1415f4a273ea70a/swarmauri_tool_qrcodegenerator-0.9.3.dev5.tar.gz | source | sdist | null | false | 4ec50c5935866bc2e08e087b9849e7bb | 0df179dcdf0f781b3060996b6be93b6f5009b4c3eb46b327ac330fa3aab336a6 | f830dfa47090677b5ee5e1846e1f31e739a3db3ec18b0c7af1415f4a273ea70a | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_lexicaldensity | 0.9.3.dev5 | Lexical Density Tool for Swarmauri. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_lexicaldensity/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_lexicaldensity" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_lexicaldensity/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_lexicaldensity.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_lexicaldensity/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_lexicaldensity" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_lexicaldensity/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_lexicaldensity" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_lexicaldensity/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_lexicaldensity?label=swarmauri_tool_lexicaldensity&color=green" alt="PyPI - swarmauri_tool_lexicaldensity"/></a>
</p>
---
# Swarmauri Tool · Lexical Density
A Swarmauri-compatible NLP utility that measures the lexical density of text—the ratio of content words (nouns, verbs, adjectives, adverbs) versus the total token count. Use it to monitor writing complexity, automate readability checks, or surface style signals inside agent conversations.
- Tokenizes input with NLTK and tags parts of speech to isolate lexical items.
- Returns a percentage score so changes in density are easy to compare between drafts.
- Ships as a Swarmauri tool, ready for registration inside agents or pipelines.
## Requirements
- Python 3.10 – 3.13.
- `nltk` with the `punkt_tab` and `averaged_perceptron_tagger_eng` resources available (downloaded at runtime).
- `textstat` for robust lexicon counting.
- Core dependencies (`swarmauri_base`, `swarmauri_standard`, `pydantic`).
## Installation
Pick the installer that matches your project; each command resolves the transitive requirements.
**pip**
```bash
pip install swarmauri_tool_lexicaldensity
```
**Poetry**
```bash
poetry add swarmauri_tool_lexicaldensity
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_lexicaldensity
# or install into the running environment without touching pyproject.toml
uv pip install swarmauri_tool_lexicaldensity
```
> Tip: If you deploy in an offline environment, download the required NLTK models during build time (`python -m nltk.downloader punkt_tab averaged_perceptron_tagger_eng`).
## Quick Start
```python
from swarmauri_tool_lexicaldensity import LexicalDensityTool
text = "This report summarizes quarterly revenue growth across all segments."
lexical_density_tool = LexicalDensityTool()
result = lexical_density_tool(text)
print(result)
# {'lexical_density': 58.333333333333336}
```
The tool returns a floating-point percentage. Use the same instance to score multiple passages.
## Usage Scenarios
### Enforce Style Guidelines in Content Pipelines
```python
from swarmauri_tool_lexicaldensity import LexicalDensityTool
product_copy = "Introducing our new AI-powered workstation with modular expansion."
checker = LexicalDensityTool()
score = checker(product_copy)["lexical_density"]
if score < 40:
raise ValueError(f"Copy too simple (density={score:.1f}%). Add more substantive language.")
```
Gate marketing copy or documentation PRs based on desired complexity thresholds.
### Analyze Conversations in a Swarmauri Agent
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_lexicaldensity import LexicalDensityTool
registry = ToolRegistry()
registry.register(LexicalDensityTool())
agent = Agent(tool_registry=registry)
utterance = "Could you elaborate on the architectural trade-offs in the data plane?"
result = agent.tools["LexicalDensityTool"](utterance)
print(result)
```
Use lexical density as a signal to adjust agent tone or escalate queries to human operators.
### Batch Score Documents and Track Trends
```python
from pathlib import Path
from swarmauri_tool_lexicaldensity import LexicalDensityTool
lexical_density = LexicalDensityTool()
corpus_dir = Path("reports/")
scores = []
for doc in corpus_dir.glob("*.txt"):
text = doc.read_text(encoding="utf-8")
scores.append((doc.name, lexical_density(text)["lexical_density"]))
for name, score in sorted(scores, key=lambda item: item[1], reverse=True):
print(f"{name}: {score:.2f}% lexical words")
```
Monitor writing complexity across a corpus of articles or support responses.
## Troubleshooting
- **`LookupError` for NLTK resources** – Ensure `punkt_tab` and `averaged_perceptron_tagger_eng` are downloaded prior to calling the tool (see `nltk.download(...)`).
- **Low density on short texts** – Very short messages yield coarse percentages. Aggregate multiple utterances or relax thresholds for brief content.
- **Non-English text** – POS tagging models target English. Swap in language-specific models before using the tool with multilingual corpora.
## License
`swarmauri_tool_lexicaldensity` is released under the Apache 2.0 License. See `LICENSE` for full details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, lexicaldensity, lexical, density | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Topic :: Software De... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nltk>=3.9.1",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard",
"textstat>=0.7.4"
] | [] | [] | [] | [] | 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-18T09:51:18.961364 | swarmauri_tool_lexicaldensity-0.9.3.dev5-py3-none-any.whl | 9,593 | 88/1a/5441847c07abf8c77f708b568898bf64cb1651ba32c1c99e2b0290592328/swarmauri_tool_lexicaldensity-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | f884945cbb06aef0ec5f8f9d4dcdbdc0 | 0bc069edad3d9531091bf54b92e1e443bb131addd251c77bf0ba01f3713f24a4 | 881a5441847c07abf8c77f708b568898bf64cb1651ba32c1c99e2b0290592328 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterwritenotebook | 0.8.3.dev5 | A tool that writes a NotebookNode object to a file in JSON format, preserving the notebook structure. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterwritenotebook/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterwritenotebook" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterwritenotebook/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterwritenotebook.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterwritenotebook/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterwritenotebook" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterwritenotebook/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterwritenotebook" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterwritenotebook/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterwritenotebook?label=swarmauri_tool_jupyterwritenotebook&color=green" alt="PyPI - swarmauri_tool_jupyterwritenotebook"/></a>
</p>
---
# Swarmauri Tool · Jupyter Write Notebook
A Swarmauri automation tool that serializes Jupyter `NotebookNode` objects (or compatible dictionaries) to disk using the nbformat JSON schema. It encapsulates validation, encoding, and integrity checks so pipelines can persist generated notebooks with confidence.
- Writes notebooks with pretty-printed JSON (`indent=2`) and `ensure_ascii=False` for readable diffs and Unicode safety.
- Performs a read-back verification step to guarantee the file contains valid JSON data.
- Slots directly into agent workflows via the standard Swarmauri tool registration system.
## Requirements
- Python 3.10 – 3.13.
- `nbformat` for working with notebook structures.
- Dependencies (`swarmauri_base`, `swarmauri_standard`, `pydantic`). These install automatically with the package.
## Installation
Choose the installer that matches your workflow—each command pulls transitive dependencies.
**pip**
```bash
pip install swarmauri_tool_jupyterwritenotebook
```
**Poetry**
```bash
poetry add swarmauri_tool_jupyterwritenotebook
```
**uv**
```bash
# Add to the active project and update uv.lock
uv add swarmauri_tool_jupyterwritenotebook
# or install into the current environment without modifying pyproject.toml
uv pip install swarmauri_tool_jupyterwritenotebook
```
> Tip: When using uv in this repository, run commands from the repo root so uv can resolve the shared `pyproject.toml`.
## Quick Start
Generate a notebook programmatically and persist it with the tool. The response dictionary includes either a success message and file path or an error string.
```python
from nbformat.v4 import new_notebook, new_markdown_cell, new_code_cell
from swarmauri_tool_jupyterwritenotebook import JupyterWriteNotebookTool
nb = new_notebook(
cells=[
new_markdown_cell("# Metrics Report"),
new_code_cell("print('accuracy:', 0.91)")
],
metadata={
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
}
}
)
write_notebook = JupyterWriteNotebookTool()
result = write_notebook(notebook_data=nb, output_file="reports/metrics.ipynb")
print(result)
# {'message': 'Notebook written successfully', 'file_path': 'reports/metrics.ipynb'}
```
## Usage Scenarios
### Persist Notebook Output From an Agent
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_jupyterwritenotebook import JupyterWriteNotebookTool
registry = ToolRegistry()
registry.register(JupyterWriteNotebookTool())
agent = Agent(tool_registry=registry)
# Agent actions produce notebook JSON (truncated for brevity)
notebook_payload = {
"cells": [
{"cell_type": "code", "source": "print('done')", "metadata": {}, "outputs": []}
],
"metadata": {"kernelspec": {"name": "python3"}},
"nbformat": 4,
"nbformat_minor": 5
}
response = agent.tools["JupyterWriteNotebookTool"](
notebook_data=notebook_payload,
output_file="runs/output.ipynb"
)
print(response)
```
Register the tool alongside other Swarmauri components so agents can emit notebooks as part of a conversation or workflow.
### Convert Executed Notebooks to Artifacts
```python
import nbformat
from nbformat import NotebookNode
from swarmauri_tool_jupyterwritenotebook import JupyterWriteNotebookTool
# Assume executed_notebook is a NotebookNode returned by nbconvert or papermill
executed_notebook: NotebookNode = nbformat.read("executed.ipynb", as_version=4)
executed_notebook.metadata.setdefault("tags", []).append("validated")
writer = JupyterWriteNotebookTool()
artifact = writer(notebook_data=executed_notebook, output_file="artifacts/executed.ipynb")
print(artifact)
```
This pattern is useful for CI systems that run notebooks and archive the executed results for review.
### Chain With Validation Before Publishing
```python
import nbformat
from swarmauri_tool_jupytervalidatenotebook import JupyterValidateNotebookTool
from swarmauri_tool_jupyterwritenotebook import JupyterWriteNotebookTool
nb = nbformat.read("draft.ipynb", as_version=4)
validate = JupyterValidateNotebookTool()
write = JupyterWriteNotebookTool()
validation = validate(nb)
if validation["valid"] != "True":
raise RuntimeError(validation["report"])
result = write(notebook_data=nb, output_file="dist/published.ipynb")
print(result)
```
Validate the notebook schema first, then persist the approved version for distribution.
## Troubleshooting
- **`An error occurred during notebook write operation`** – The tool surfaces file-system exceptions verbatim. Check write permissions and ensure the target directory exists.
- **Empty file after execution** – Read-back verification triggers when the file cannot be parsed as JSON. Confirm the notebook structure is JSON serializable (e.g., use nbformat helper constructors).
- **Unexpected characters** – The tool writes with `ensure_ascii=False` so non-ASCII text remains intact. If your environment cannot handle UTF-8, pass a different `encoding` argument.
## License
`swarmauri_tool_jupyterwritenotebook` is released under the Apache 2.0 License. See `LICENSE` for the full text.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterwritenotebook, writes, notebooknode, object, file, json, format, preserving, notebook, structure | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nbformat>=5.10.4",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:15.805800 | swarmauri_tool_jupyterwritenotebook-0.8.3.dev5.tar.gz | 9,391 | 53/44/ee9e72253353116ccfbda16cc30b358fded3c7df167458120279edaea558/swarmauri_tool_jupyterwritenotebook-0.8.3.dev5.tar.gz | source | sdist | null | false | ed8197b2fed7668b637aefd465d02925 | f0ec58b82595676bb5f1be67b36e0bb9d0be238c07f56aef6a24075c9d1d6766 | 5344ee9e72253353116ccfbda16cc30b358fded3c7df167458120279edaea558 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupytershutdownkernel | 0.8.3.dev5 | A tool designed to shut down a running Jupyter kernel programmatically using jupyter_client, releasing all associated resources. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupytershutdownkernel/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupytershutdownkernel" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytershutdownkernel/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytershutdownkernel.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytershutdownkernel/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupytershutdownkernel" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytershutdownkernel/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupytershutdownkernel" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytershutdownkernel/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupytershutdownkernel?label=swarmauri_tool_jupytershutdownkernel&color=green" alt="PyPI - swarmauri_tool_jupytershutdownkernel"/></a>
</p>
---
# Swarmauri Tool · Jupyter Shutdown Kernel
A Swarmauri-compatible utility that performs graceful or forced shutdowns of running Jupyter kernels. It is ideal for automated resource clean-up, CI workflows that recycle kernels between test suites, and agents that need to reclaim compute when a conversation finishes.
- Supports graceful and forced shutdown paths with configurable timeouts.
- Returns structured status payloads suitable for orchestration pipelines.
- Builds on `swarmauri_base`/`swarmauri_standard` abstractions so it can be registered like any other tool inside a Swarmauri agent graph.
## Requirements
- Python 3.10 – 3.13.
- Local access to the target kernel's connection file (typically lives in Jupyter's runtime directory on the same host).
- Dependencies (`jupyter_client`, `swarmauri_base`, `swarmauri_standard`, `pydantic`) install automatically with the package.
## Installation
Install the package with the workflow that matches your environment. All commands below resolve transitive dependencies.
**pip**
```bash
pip install swarmauri_tool_jupytershutdownkernel
```
**Poetry**
```bash
poetry add swarmauri_tool_jupytershutdownkernel
```
**uv**
```bash
# Add to the current project and lockfile
uv add swarmauri_tool_jupytershutdownkernel
# or install into the active environment without editing pyproject.toml
uv pip install swarmauri_tool_jupytershutdownkernel
```
> Tip: When using uv inside this repository, run commands from the repository root so `uv` can discover the consolidated `pyproject.toml`.
## Quick Start
The tool exposes a callable interface. Instantiate it and provide the kernel identifier along with an optional timeout (seconds). The identifier should match the `kernel_id` used by Jupyter when the connection file `kernel-<kernel_id>.json` is created.
```python
from jupyter_client import KernelManager
from swarmauri_tool_jupytershutdownkernel import JupyterShutdownKernelTool
# 1. Launch a kernel (acts as stand-in for an existing notebook kernel).
km = KernelManager(kernel_name="python3")
km.start_kernel()
# 2. Capture the kernel identifier Jupyter assigned (UUID-style string).
kernel_identifier = km.kernel_id or km.connection_file.split("kernel-")[-1].split(".json")[0]
print(f"Kernel identifier: {kernel_identifier}")
# 3. Shut the kernel down with the Swarmauri tool.
shutdown_tool = JupyterShutdownKernelTool()
response = shutdown_tool(kernel_id=kernel_identifier, shutdown_timeout=10)
print(response)
```
The returned dictionary always contains `kernel_id`, `status`, and `message`. A `status` of `error` indicates the tool attempted a forced shutdown or encountered an issue loading the connection file.
## Usage Scenarios
### Automate Notebook Clean-up After Batch Execution
```python
import json
from pathlib import Path
from swarmauri_tool_jupytershutdownkernel import JupyterShutdownKernelTool
runtime_dir = Path.home() / ".local" / "share" / "jupyter" / "runtime"
shutdown_tool = JupyterShutdownKernelTool()
for connection_file in runtime_dir.glob("kernel-*.json"):
kernel_id = connection_file.stem.replace("kernel-", "")
result = shutdown_tool(kernel_id=kernel_id, shutdown_timeout=5)
print(json.dumps(result, indent=2))
```
This script discovers every live kernel connection file on the current host and attempts to close it gracefully. It is useful for CI jobs that leave stray kernels active between notebook test suites.
### Shut Down Kernels Started Via `MultiKernelManager`
```python
from jupyter_client import MultiKernelManager
from swarmauri_tool_jupytershutdownkernel import JupyterShutdownKernelTool
multi = MultiKernelManager()
# Start a new kernel for an integration test and capture its UUID.
kernel_id = multi.start_kernel(kernel_name="python3")
print(f"Started kernel with id={kernel_id}")
# Run your test suite against the kernel ...
# When finished, shut it down through the Swarmauri tool.
shutdown_tool = JupyterShutdownKernelTool()
result = shutdown_tool(kernel_id=kernel_id, shutdown_timeout=8)
print(result)
```
Because `MultiKernelManager` stores connection files under the standard `kernel-<kernel_id>.json` naming pattern, the shutdown tool can resolve the same kernel and close it without needing direct access to the `MultiKernelManager` instance that launched it.
## Troubleshooting
- **`No such kernel`** – The tool could not locate a matching connection file. Make sure the process has read access to Jupyter's runtime directory and that you pass the raw identifier (for example, `03c7d8f9-ec4d-4a8a-8a90-cdb35ff9e6c9`).
- **`Connection file not found`** – The connection file was deleted or the kernel lives on a different machine. Run the shutdown tool on the same host where the kernel was started.
- **Forced shutdowns** – If the kernel remains alive after the timeout expires, the tool switches to a forced shutdown. You can increase `shutdown_timeout` to give busy kernels more time to finish.
- **Sandboxed environments** – Some containerized or restricted environments may block the network ports that Jupyter kernels use. In those cases, start kernels with appropriate permissions before attempting to shut them down programmatically.
## License
`swarmauri_tool_jupytershutdownkernel` is released under the Apache 2.0 License. See `LICENSE` for details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupytershutdownkernel, designed, shut, down, running, jupyter, kernel, programmatically, client, releasing, all, associated, resources | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"jupyter_client>=8.6.3",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:14.109214 | swarmauri_tool_jupytershutdownkernel-0.8.3.dev5-py3-none-any.whl | 10,995 | d6/bb/66e0368c705fb44960b68c2ac13bcad14c9c9bc7c612c3fc7b222311bbe8/swarmauri_tool_jupytershutdownkernel-0.8.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | de9175085bf26714eeab14b072e97141 | 094e0792112821a0fa5e3a019d3a055dd824e899a7a0c33de0cb4c21a350db37 | d6bb66e0368c705fb44960b68c2ac13bcad14c9c9bc7c612c3fc7b222311bbe8 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupytervalidatenotebook | 0.9.3.dev5 | A tool that validates a NotebookNode object against the Jupyter Notebook schema using nbformat, ensuring structural correctness. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupytervalidatenotebook/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupytervalidatenotebook" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytervalidatenotebook/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytervalidatenotebook.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytervalidatenotebook/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupytervalidatenotebook" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytervalidatenotebook/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupytervalidatenotebook" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytervalidatenotebook/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupytervalidatenotebook?label=swarmauri_tool_jupytervalidatenotebook&color=green" alt="PyPI - swarmauri_tool_jupytervalidatenotebook"/></a>
</p>
---
# Swarmauri Tool · Jupyter Validate Notebook
A Swarmauri tool that validates Jupyter notebooks (`NotebookNode` objects) against the official nbformat JSON schema. Use it to gate notebook submissions, enforce structural best practices, or wire schema checks into automated notebook pipelines.
- Accepts in-memory `NotebookNode` instances and produces structured success/error payloads.
- Surfaces detailed schema violations coming from nbformat/jsonschema.
- Integrates with Swarmauri agents via the standard tool registration workflow.
## Requirements
- Python 3.10 – 3.13.
- `nbformat` (installed automatically) with access to the notebook JSON schema.
- Dependencies (`jsonschema`, `swarmauri_base`, `swarmauri_standard`, `pydantic`, `typing_extensions`).
## Installation
Pick the installer that matches your workflow; each command resolves transitive packages.
**pip**
```bash
pip install swarmauri_tool_jupytervalidatenotebook
```
**Poetry**
```bash
poetry add swarmauri_tool_jupytervalidatenotebook
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_jupytervalidatenotebook
# or install into the active environment without touching pyproject.toml
uv pip install swarmauri_tool_jupytervalidatenotebook
```
> Tip: When using uv inside this repo, run uv commands from the repository root so it can locate the shared `pyproject.toml`.
## Quick Start
Load a notebook with nbformat, then pass the resulting `NotebookNode` to the tool. The response dictionary contains string values for `valid` (`"True"` or `"False"`) and a human-readable `report`.
```python
import nbformat
from swarmauri_tool_jupytervalidatenotebook import JupyterValidateNotebookTool
notebook = nbformat.read("analysis.ipynb", as_version=4)
validate = JupyterValidateNotebookTool()
result = validate(notebook)
if result["valid"] == "True":
print("Notebook passes schema validation")
else:
raise ValueError(result["report"])
```
## Usage Scenarios
### Batch Validate an Entire Notebook Directory
```python
import nbformat
from pathlib import Path
from swarmauri_tool_jupytervalidatenotebook import JupyterValidateNotebookTool
validator = JupyterValidateNotebookTool()
notebook_dir = Path("notebooks")
for path in notebook_dir.glob("**/*.ipynb"):
nb = nbformat.read(path, as_version=4)
result = validator(nb)
status = "PASS" if result["valid"] == "True" else "FAIL"
print(f"[{status}] {path}: {result['report']}")
```
Drop this snippet into CI to stop merges when any notebook violates the schema.
### Fail a Build When Validation Fails
```python
import sys
import nbformat
from swarmauri_tool_jupytervalidatenotebook import JupyterValidateNotebookTool
validator = JupyterValidateNotebookTool()
notebook = nbformat.read(sys.argv[1], as_version=4)
result = validator(notebook)
print(result["report"])
if result["valid"] != "True":
sys.exit(1)
```
Wire the script into a pre-commit hook or build step (`python validate.py path/to/notebook.ipynb`).
### Combine With Other Swarmauri Tools
```python
from swarmauri_tool_jupyterstartkernel import JupyterStartKernelTool
from swarmauri_tool_jupytervalidatenotebook import JupyterValidateNotebookTool
start_kernel = JupyterStartKernelTool()
validate_notebook = JupyterValidateNotebookTool()
launch = start_kernel()
print(f"Launched kernel: {launch['kernel_id']}")
# After generating a notebook programmatically, load and validate it
import nbformat
nb = nbformat.read("generated.ipynb", as_version=4)
validation = validate_notebook(nb)
print(validation)
```
Use the validation step after automated notebook generation/execution to ensure outputs remain schema-compliant.
## Troubleshooting
- **`Invalid nbformat version`** – The tool enforces nbformat version 4. Upgrade the notebook (`nbformat.convert`) or save it with a modern Jupyter client.
- **`Validation error`** – Inspect the `report` field for the jsonschema path causing the failure. Missing metadata or malformed cells are common culprits.
- **`Unexpected error`** – Log the exception and confirm the input is an nbformat `NotebookNode`, not a raw dict or path string.
## License
`swarmauri_tool_jupytervalidatenotebook` is released under the Apache 2.0 License. See `LICENSE` for full text.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupytervalidatenotebook, validates, notebooknode, object, against, jupyter, notebook, schema, nbformat, ensuring, structural, correctness | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nbformat>=5.10.4",
"pydantic>=2.10.6",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard",
"typing_extensions>=4.12.2"
] | [] | [] | [] | [] | 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-18T09:51:11.807991 | swarmauri_tool_jupytervalidatenotebook-0.9.3.dev5-py3-none-any.whl | 9,854 | 63/48/7d0936865cefc51e43e88472a05b06192dc1edf653583898ecd8bedf0cda/swarmauri_tool_jupytervalidatenotebook-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | 55b3bf614faa2b9a8e23b68c5ced0d59 | 5b01f9825e67454e4eb09e2a797f0fb214c97eb47d9cf7e21a01b9bee33d3647 | 63487d0936865cefc51e43e88472a05b06192dc1edf653583898ecd8bedf0cda | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterstartkernel | 0.9.3.dev5 | A tool designed to start a new Jupyter kernel programmatically using jupyter_client, enabling execution of notebook cells. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterstartkernel/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterstartkernel" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterstartkernel/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterstartkernel.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterstartkernel/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterstartkernel" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterstartkernel/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterstartkernel" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterstartkernel/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterstartkernel?label=swarmauri_tool_jupyterstartkernel&color=green" alt="PyPI - swarmauri_tool_jupyterstartkernel"/></a>
</p>
---
# Swarmauri Tool · Jupyter Start Kernel
A Swarmauri orchestration tool that spins up Jupyter kernels on demand using `jupyter_client`. The helper wraps connection-file management, kernel specification, and timeout handling so automation pipelines, notebook CI, or Swarmauri agents can acquire fresh kernels with one function call.
- Launches kernels with configurable names and kernel-spec overrides.
- Surfaces ready-to-use connection metadata for downstream orchestration.
- Keeps a reference to the underlying `KernelManager` so you can interact with the kernel lifecycle after launch.
## Requirements
- Python 3.10 – 3.13.
- The environment must have Jupyter kernel specs installed (for example the default `python3`).
- Dependencies (`jupyter_client`, `swarmauri_base`, `swarmauri_standard`, `pydantic`) install automatically.
## Installation
Install via the packaging tool that matches your workflow. Each command fetches transitive dependencies.
**pip**
```bash
pip install swarmauri_tool_jupyterstartkernel
```
**Poetry**
```bash
poetry add swarmauri_tool_jupyterstartkernel
```
**uv**
```bash
# Add to the current project and update uv.lock
uv add swarmauri_tool_jupyterstartkernel
# or install into the active environment without touching pyproject.toml
uv pip install swarmauri_tool_jupyterstartkernel
```
> Tip: When using uv inside this repository, run commands from the repository root so `uv` can resolve the shared `pyproject.toml`.
## Quick Start
The tool behaves like a callable. Instantiate it and optionally pass a `kernel_name`, timeout, or kernel spec.
```python
from swarmauri_tool_jupyterstartkernel import JupyterStartKernelTool
start_kernel = JupyterStartKernelTool()
result = start_kernel() # defaults to python3
print(result)
# {
# 'status': 'success',
# 'kernel_id': '03c7d8f9-ec4d-4a8a-8a90-cdb35ff9e6c9',
# 'kernel_name': 'python3',
# 'connection_file': '/Users/.../jupyter/runtime/kernel-03c7d8f9.json'
# }
```
A non-success status signals the kernel failed to spawn (missing kernelspec, permission issue, etc.).
## Usage Scenarios
### Launch With Custom Specification
```python
from swarmauri_tool_jupyterstartkernel import JupyterStartKernelTool
start_kernel = JupyterStartKernelTool()
config = {
"env": {"EXPERIMENT_FLAG": "1"},
"resource_limits": {"memory": "1G"}
}
custom = start_kernel(kernel_name="python3", kernel_spec=config, startup_timeout=20)
if custom["status"] == "success":
print(f"Kernel ready at {custom['connection_file']}")
else:
raise RuntimeError(custom["message"])
```
Pass a `kernel_spec` dict to tweak environment variables or other launch parameters that the underlying `KernelManager` accepts.
### Pair With the Shutdown Tool in an Automated Flow
```python
from swarmauri_tool_jupyterstartkernel import JupyterStartKernelTool
from swarmauri_tool_jupytershutdownkernel import JupyterShutdownKernelTool
start_kernel = JupyterStartKernelTool()
shutdown_kernel = JupyterShutdownKernelTool()
launch = start_kernel(kernel_name="python3")
if launch["status"] != "success":
raise RuntimeError(launch["message"])
kernel_id = launch["kernel_id"]
print(f"Kernel started: {kernel_id}")
# ... run your notebook execution workflow ...
cleanup = shutdown_kernel(kernel_id=kernel_id, shutdown_timeout=10)
print(cleanup)
```
Use this pairing in CI pipelines or agent flows that must guarantee kernels are torn down after execution.
### Integrate Inside a Swarmauri Agent
```python
from swarmauri_core.agent.Agent import Agent
from swarmauri_core.messages.HumanMessage import HumanMessage
from swarmauri_standard.tools.registry import ToolRegistry
from swarmauri_tool_jupyterstartkernel import JupyterStartKernelTool
registry = ToolRegistry()
registry.register(JupyterStartKernelTool())
agent = Agent(tool_registry=registry)
message = HumanMessage(content="start a python3 kernel for my notebook batch job")
response = agent.run(message)
print(response)
```
The agent resolves the registered tool, starts a kernel, and returns the connection metadata to the conversation context.
## Troubleshooting
- **`No such kernel`** – The requested `kernel_name` is not installed. Check `jupyter kernelspec list`.
- **`Kernel start timeout exceeded`** – Increase `startup_timeout` for slow environments or pre-warm interpreters.
- **Permission errors** – Ensure the process can create files inside Jupyter's runtime directory (usually `~/.local/share/jupyter/runtime`).
## License
`swarmauri_tool_jupyterstartkernel` is released under the Apache 2.0 License. See `LICENSE` for details.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterstartkernel, designed, start, new, jupyter, kernel, programmatically, client, enabling, execution, notebook, cells | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"ipykernel>=6.29.5",
"jupyter_client>=8.6.3",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:51:11.210392 | swarmauri_tool_jupyterstartkernel-0.9.3.dev5-py3-none-any.whl | 10,044 | f3/2a/9b9a8f5c4df0f491f6590c1230dad329e29cfa3f1b36a0aa27b97bb195e6/swarmauri_tool_jupyterstartkernel-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | bb184653a09cb50058132df9b9c7a030 | 5d20735f9c584e0e13817745e84d41e4702857548cc3f791c5649d892d40c7b5 | f32a9b9a8f5c4df0f491f6590c1230dad329e29cfa3f1b36a0aa27b97bb195e6 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterreadnotebook | 0.8.3.dev5 | A tool that reads a Jupyter Notebook file using nbformat, converting the JSON file into a NotebookNode object. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterreadnotebook/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterreadnotebook" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterreadnotebook/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterreadnotebook.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterreadnotebook/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterreadnotebook" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterreadnotebook/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterreadnotebook" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterreadnotebook/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterreadnotebook?label=swarmauri_tool_jupyterreadnotebook&color=green" alt="PyPI - swarmauri_tool_jupyterreadnotebook"/></a>
</p>
---
# Swarmauri Tool Jupyter Read Notebook
Reads a `.ipynb` file from disk into a validated nbformat `NotebookNode` for downstream processing.
## Features
- Wraps nbformat’s `read` + validation workflow in a Swarmauri tool.
- Returns `{ "notebook_node": NotebookNode }` on success or `{ "error": ... }` on failure.
- Optional `as_version` argument controls notebook parsing version (default 4).
## Prerequisites
- Python 3.10 or newer.
- nbformat installed (pulled automatically).
## Installation
```bash
# pip
pip install swarmauri_tool_jupyterreadnotebook
# poetry
poetry add swarmauri_tool_jupyterreadnotebook
# uv (pyproject-based projects)
uv add swarmauri_tool_jupyterreadnotebook
```
## Quickstart
```python
from swarmauri_tool_jupyterreadnotebook import JupyterReadNotebookTool
reader = JupyterReadNotebookTool()
response = reader(
notebook_file_path="notebooks/example.ipynb",
as_version=4,
)
if "notebook_node" in response:
nb = response["notebook_node"]
print("Cells:", len(nb.cells))
else:
print("Error:", response["error"])
```
## Tips
- Use with execution/export tools to build pipelines (read → execute → convert).
- Handle `error` key gracefully when files are missing or malformed.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterreadnotebook, reads, jupyter, notebook, file, nbformat, converting, json, notebooknode, object | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nbformat>=5.10.4",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:55.779409 | swarmauri_tool_jupyterreadnotebook-0.8.3.dev5.tar.gz | 7,867 | fd/ec/5b91da7e14f03a9f90364ee63ccc4484d019baf4a97382552ea0e034e818/swarmauri_tool_jupyterreadnotebook-0.8.3.dev5.tar.gz | source | sdist | null | false | de492368b18d53212565ac42fa9a38a7 | fb2e2106e5429e72441edcef5289c534005af0bdaa6c71a8d1cea574cd3a7953 | fdec5b91da7e14f03a9f90364ee63ccc4484d019baf4a97382552ea0e034e818 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterruncell | 0.9.3.dev5 | A tool designed to execute a single code cell in an IPython interactive shell, mimicking notebook cell execution. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterruncell/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterruncell" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterruncell/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterruncell.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterruncell/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterruncell" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterruncell/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterruncell" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterruncell/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterruncell?label=swarmauri_tool_jupyterruncell&color=green" alt="PyPI - swarmauri_tool_jupyterruncell"/></a>
</p>
---
# Swarmauri Tool Jupyter Run Cell
Executes a code string inside the current IPython kernel and captures stdout/stderr/error text.
## Features
- Runs arbitrary Python snippets with optional timeout.
- Returns `success`, `cell_output`, and `error_output` keys.
- Designed for use inside running notebooks or IPython sessions.
## Prerequisites
- Python 3.10 or newer.
- Running within IPython/Jupyter environment.
## Installation
```bash
# pip
pip install swarmauri_tool_jupyterruncell
# poetry
poetry add swarmauri_tool_jupyterruncell
# uv (pyproject-based projects)
uv add swarmauri_tool_jupyterruncell
```
## Quickstart
```python
from swarmauri_tool_jupyterruncell import JupyterRunCellTool
runner = JupyterRunCellTool()
result = runner(code="print('Hello from Swarmauri!')", timeout=5)
if result["success"]:
print("stdout:", result["cell_output"])
else:
print("error:", result["error_output"])
```
## Tips
- Set `timeout=0` (or omit) to disable execution timeouts.
- Capture `error_output` to diagnose exceptions raised by the executed code.
- Use alongside other notebook automation tools (execute, export, etc.) to build richer pipelines.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterruncell, designed, execute, single, code, cell, ipython, interactive, shell, mimicking, notebook, execution | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"IPython>=8.32.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:54.760847 | swarmauri_tool_jupyterruncell-0.9.3.dev5.tar.gz | 8,412 | bf/85/97b497cff90a47fe583b8bb43c5eea2b88a2c10c7f10a82018ad3d13a4d1/swarmauri_tool_jupyterruncell-0.9.3.dev5.tar.gz | source | sdist | null | false | 001b7e6e06cff656bfdea63b66e66d10 | 9f08c9ebccf5e57733f46427dee7865222a10e8c288c8114b03c90c50b4143e1 | bf8597b497cff90a47fe583b8bb43c5eea2b88a2c10c7f10a82018ad3d13a4d1 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupytergetshellmessage | 0.9.3.dev5 | A tool designed to retrieve shell messages from a running Jupyter kernel using jupyter_client, useful for debugging execution responses. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupytergetshellmessage/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupytergetshellmessage" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytergetshellmessage/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytergetshellmessage.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytergetshellmessage/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupytergetshellmessage" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytergetshellmessage/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupytergetshellmessage" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytergetshellmessage/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupytergetshellmessage?label=swarmauri_tool_jupytergetshellmessage&color=green" alt="PyPI - swarmauri_tool_jupytergetshellmessage"/></a>
</p>
---
# Swarmauri Tool Jupyter Get Shell Message
Retrieves shell-channel messages from a running Jupyter kernel using `jupyter_client`.
## Features
- Listens on the Jupyter kernel shell channel and captures raw message dicts.
- Returns a dict containing `messages` or an `error` key.
- Helpful for debugging live kernel communication during automated notebook workflows.
## Prerequisites
- Python 3.10 or newer.
- Access to a running Jupyter kernel (Notebook server, JupyterLab, etc.).
- `jupyter_client` and `websocket-client` (installed automatically).
## Installation
```bash
# pip
pip install swarmauri_tool_jupytergetshellmessage
# poetry
poetry add swarmauri_tool_jupytergetshellmessage
# uv (pyproject-based projects)
uv add swarmauri_tool_jupytergetshellmessage
```
## Quickstart
```python
from swarmauri_tool_jupytergetshellmessage import JupyterGetShellMessageTool
channels_url = "ws://localhost:8888/api/kernels/<kernel-id>/channels"
result = JupyterGetIOPubMessageTool()(channels_url, timeout=5.0)
if "messages" in result:
for msg in result["messages"]:
print(msg)
else:
print("Error:", result.get("error"))
```
## Tips
- Ensure you pass the correct kernel channels URL (including security tokens/cookies if your server requires them).
- Increase `timeout` if you expect long-running cells before shell replies are sent.
- Combine with notebook execution tools to capture both SHELL and IOPub messages for full observability.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupytergetshellmessage, designed, retrieve, shell, messages, running, jupyter, kernel, client, useful, debugging, execution, responses | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"ipykernel>=6.29.5",
"jupyter_client>=8.6.3",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:52.190259 | swarmauri_tool_jupytergetshellmessage-0.9.3.dev5-py3-none-any.whl | 10,223 | 6a/86/55062045081efdab338e2a39f59a72eed47bdbd9086292c0aa0889d82fb0/swarmauri_tool_jupytergetshellmessage-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | 9bc00ecbad88d8b85e6a01de9b60144b | 40b8c9e7fb1b9f202df56a96a347ca3d226e49f8db2c9ae804fad3d9ab2ab581 | 6a8655062045081efdab338e2a39f59a72eed47bdbd9086292c0aa0889d82fb0 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupytergetiopubmessage | 0.8.3.dev5 | A tool designed to retrieve messages from the IOPub channel of a Jupyter kernel using jupyter_client, capturing cell outputs and logs. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupytergetiopubmessage/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupytergetiopubmessage" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytergetiopubmessage/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupytergetiopubmessage.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytergetiopubmessage/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupytergetiopubmessage" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytergetiopubmessage/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupytergetiopubmessage" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupytergetiopubmessage/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupytergetiopubmessage?label=swarmauri_tool_jupytergetiopubmessage&color=green" alt="PyPI - swarmauri_tool_jupytergetiopubmessage"/></a>
</p>
---
# Swarmauri Tool Jupyter Get IOPub Message
Listens to a Jupyter kernel’s IOPub channel and collects stdout/stderr/log messages for downstream processing.
## Features
- Connects to `/api/kernels/{id}/channels` via websocket.
- Returns a dict containing captured `stdout`, `stderr`, `logs`, `execution_results`, and a `timeout_exceeded` flag.
- Built on `jupyter_client` with Swarmauri tool registration.
## Prerequisites
- Python 3.10 or newer.
- `jupyter_client`, `websocket-client` installed (pulled automatically).
- Access to a running Jupyter kernel (e.g., Notebook server).
## Installation
```bash
# pip
pip install swarmauri_tool_jupytergetiopubmessage
# poetry
poetry add swarmauri_tool_jupytergetiopubmessage
# uv (pyproject-based projects)
uv add swarmauri_tool_jupytergetiopubmessage
```
## Quickstart
```python
from swarmauri_tool_jupytergetiopubmessage import JupyterGetIOPubMessageTool
channels_url = "ws://localhost:8888/api/kernels/<kernel-id>/channels"
result = JupyterGetIOPubMessageTool()(channels_url, timeout=3.0)
print("stdout:", result["stdout"])
print("stderr:", result["stderr"])
print("logs:", result["logs"])
print("timeout?", result["timeout_exceeded"])
```
## Tips
- Use alongside execution tools to capture live output during automated notebook runs.
- Ensure your environment handles Jupyter tokens/cookies if the server requires authentication.
- Increase `timeout` for longer-running cells to collect all outputs before returning.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupytergetiopubmessage, designed, retrieve, messages, iopub, channel, jupyter, kernel, client, capturing, cell, outputs, logs | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"jupyter_client>=8.6.3",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard",
"websocket-client>=1.8.0"
] | [] | [] | [] | [] | 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-18T09:50:49.510611 | swarmauri_tool_jupytergetiopubmessage-0.8.3.dev5-py3-none-any.whl | 9,995 | be/92/ab89d621d92c025eb5dcfe22c1da8051a32ae6bb16b1392a60958576a035/swarmauri_tool_jupytergetiopubmessage-0.8.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | 109138e8adaeb13e020054383842234a | a6c8c91a7891883eb27667128ecea78c4e295e67709422aaa46d4fef80ee1e00 | be92ab89d621d92c025eb5dcfe22c1da8051a32ae6bb16b1392a60958576a035 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterfromdict | 0.9.2.dev4 | A tool that converts a plain dictionary into a NotebookNode object using nbformat, facilitating programmatic notebook creation. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterfromdict/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterfromdict" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterfromdict/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterfromdict.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterfromdict/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterfromdict" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterfromdict/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterfromdict" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterfromdict/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterfromdict?label=swarmauri_tool_jupyterfromdict&color=green" alt="PyPI - swarmauri_tool_jupyterfromdict"/></a>
</p>
---
# Swarmauri Tool Jupyter From Dict
Creates a validated Jupyter `NotebookNode` from a Python dictionary using nbformat.
## Features
- Validates notebook structure against nbformat schema.
- Returns `{"notebook_node": ...}` on success or `{"error": ...}` when conversion fails.
- Useful for programmatically building notebooks before executing/exporting them with other Swarmauri tools.
## Prerequisites
- Python 3.10 or newer.
- nbformat installed (pulled automatically).
## Installation
```bash
# pip
pip install swarmauri_tool_jupyterfromdict
# poetry
poetry add swarmauri_tool_jupyterfromdict
# uv (pyproject-based projects)
uv add swarmauri_tool_jupyterfromdict
```
## Quickstart
```python
import json
from swarmauri_tool_jupyterfromdict import JupyterFromDictTool
notebook_dict = {
"nbformat": 4,
"nbformat_minor": 5,
"metadata": {},
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": ["# Hello World\n", "This is a generated notebook."],
}
],
}
result = JupyterFromDictTool()(notebook_dict)
if "notebook_node" in result:
print("NotebookNode ready", type(result["notebook_node"]))
else:
print("Error:", result["error"])
```
## Tips
- Feed the resulting `NotebookNode` directly into execution/export tools such as `JupyterExecuteNotebookTool` or nbconvert exporters.
- Use `json.dumps`/`json.loads` if you need to persist or transmit the notebook dictionary before conversion.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterfromdict, converts, plain, dictionary, notebooknode, object, nbformat, facilitating, programmatic, notebook, creation | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nbformat>=5.10.4",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:47.537056 | swarmauri_tool_jupyterfromdict-0.9.2.dev4.tar.gz | 7,743 | 4c/32/5cf2869bdffb85747aed6993920ceb01606ce0152797ce0f9f2fc8c699ad/swarmauri_tool_jupyterfromdict-0.9.2.dev4.tar.gz | source | sdist | null | false | b0aaf3c2f375eecbb8e2e9c5a45f1e09 | ea6b93cdfd41fccf573ea0632fe95a2b3a819b6c3eda2c586709ad5e8ce266f2 | 4c325cf2869bdffb85747aed6993920ceb01606ce0152797ce0f9f2fc8c699ad | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterexportmarkdown | 1.3.3.dev5 | A Swarmauri tool designed to export Jupyter Notebooks to Markdown. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportmarkdown/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterexportmarkdown" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterexportmarkdown/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterexportmarkdown.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportmarkdown/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterexportmarkdown" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportmarkdown/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterexportmarkdown" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportmarkdown/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterexportmarkdown?label=swarmauri_tool_jupyterexportmarkdown&color=green" alt="PyPI - swarmauri_tool_jupyterexportmarkdown"/></a>
</p>
---
# Swarmauri Tool Jupyter Export Markdown
Converts a Jupyter `NotebookNode` to Markdown using nbconvert’s `MarkdownExporter`. Injectable CSS and JS snippets let you tweak the output for static publishing.
## Features
- Accepts a notebook JSON string and returns rendered Markdown.
- Optional inline CSS/JS injection to customize the exported document.
- Returns a dict with `exported_markdown` or `error` if conversion fails.
## Prerequisites
- Python 3.10 or newer.
- nbconvert/nbformat installed (pulled in automatically).
## Installation
```bash
# pip
pip install swarmauri_tool_jupyterexportmarkdown
# poetry
poetry add swarmauri_tool_jupyterexportmarkdown
# uv (pyproject-based projects)
uv add swarmauri_tool_jupyterexportmarkdown
```
## Quickstart
```python
import json
import nbformat
from swarmauri_tool_jupyterexportmarkdown import JupyterExportMarkdownTool
notebook = nbformat.read("notebooks/example.ipynb", as_version=4)
notebook_json = json.dumps(notebook)
exporter = JupyterExportMarkdownTool()
response = exporter(
notebook_json=notebook_json,
extra_css="blockquote { color: gray; }",
extra_js="console.log('Markdown ready');",
)
if "exported_markdown" in response:
Path("notebooks/example.md").write_text(response["exported_markdown"], encoding="utf-8")
else:
print("Error:", response["error"])
```
## Tips
- Use Markdown export when preparing notebooks for static docs, blogs, or README content.
- Apply lightweight CSS/JS to adjust styling when the Markdown is embedded in HTML environments.
- Combine with notebook execution tools to build pipelines (execute → convert to Markdown → publish).
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterexportmarkdown, designed, export, jupyter, notebooks, markdown | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"papermill>=2.6.0",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:32.508459 | swarmauri_tool_jupyterexportmarkdown-1.3.3.dev5-py3-none-any.whl | 9,781 | b8/0b/383792acb658ba9f9bd41a4a916df527162ab4cbb3a41f4ed27aee155339/swarmauri_tool_jupyterexportmarkdown-1.3.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | fffc891dde09f350dc016491cdd89463 | 69927a586387278a9b4c21e7624876eb540c169549e50527447e6e6f35460ddc | b80b383792acb658ba9f9bd41a4a916df527162ab4cbb3a41f4ed27aee155339 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterexportlatex | 0.8.3.dev5 | A tool that exports a Jupyter Notebook to LaTeX format using nbconvert’s LatexExporter, enabling further conversion to PDF. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportlatex/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterexportlatex" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterexportlatex/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterexportlatex.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportlatex/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterexportlatex" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportlatex/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterexportlatex" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportlatex/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterexportlatex?label=swarmauri_tool_jupyterexportlatex&color=green" alt="PyPI - swarmauri_tool_jupyterexportlatex"/></a>
</p>
---
# Swarmauri Tool Jupyter Export LaTeX
Converts a Jupyter `NotebookNode` into LaTeX using nbconvert; optionally generates a PDF.
## Features
- Uses nbconvert’s `LatexExporter` with optional custom template support.
- Returns the LaTeX string and (optionally) the path to a generated PDF.
- Accepts inline CSS/JS injection via nbconvert hooks.
## Prerequisites
- Python 3.10 or newer.
- nbconvert (with LaTeX/PDF dependencies such as TeXLive or Tectonic if generating PDFs).
- Swarmauri base/core packages (installed automatically).
## Installation
```bash
# pip
pip install swarmauri_tool_jupyterexportlatex
# poetry
poetry add swarmauri_tool_jupyterexportlatex
# uv (pyproject-based projects)
uv add swarmauri_tool_jupyterexportlatex
```
## Quickstart
```python
import json
import nbformat
from swarmauri_tool_jupyterexportlatex import JupyterExportLatexTool
notebook = nbformat.read("notebooks/example.ipynb", as_version=4)
exporter = JupyterExportLatexTool()
response = exporter(
notebook_node=notebook,
use_custom_template=False,
template_path=None,
to_pdf=True,
)
if "latex_content" in response:
Path("notebooks/example.tex").write_text(response["latex_content"], encoding="utf-8")
if pdf := response.get("pdf_file_path"):
print("PDF saved to", pdf)
else:
print("Error:", response.get("error"))
```
## Tips
- Install a TeX distribution (e.g., `texlive`, `tectonic`) when `to_pdf=True`.
- Use `use_custom_template=True` and `template_path` to control the LaTeX layout.
- Combine with notebook execution tools (execute → export → PDF) for reporting pipelines.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterexportlatex, exports, jupyter, notebook, latex, format, nbconvert, latexexporter, enabling, further, conversion, pdf | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nbconvert>=7.16.6",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:31.395998 | swarmauri_tool_jupyterexportlatex-0.8.3.dev5.tar.gz | 8,930 | fd/4a/78831d634c2551d3b3329121cbd89950d6ca75c57af3157d24828cb0665e/swarmauri_tool_jupyterexportlatex-0.8.3.dev5.tar.gz | source | sdist | null | false | 30edc8793f2d44c50a1420b6a95338f0 | b03833ea052a0292fd3c58bdc5fc75abefac2a008b03d977de8db2e817646f9b | fd4a78831d634c2551d3b3329121cbd89950d6ca75c57af3157d24828cb0665e | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | swarmauri_tool_jupyterexportpython | 0.9.3.dev5 | A tool that exports a Jupyter Notebook to a Python script using nbconvert’s PythonExporter, facilitating code extraction. | 
<p align="center">
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportpython/">
<img src="https://img.shields.io/pypi/dm/swarmauri_tool_jupyterexportpython" alt="PyPI - Downloads"/></a>
<a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterexportpython/">
<img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/community/swarmauri_tool_jupyterexportpython.svg"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportpython/">
<img src="https://img.shields.io/pypi/pyversions/swarmauri_tool_jupyterexportpython" alt="PyPI - Python Version"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportpython/">
<img src="https://img.shields.io/pypi/l/swarmauri_tool_jupyterexportpython" alt="PyPI - License"/></a>
<a href="https://pypi.org/project/swarmauri_tool_jupyterexportpython/">
<img src="https://img.shields.io/pypi/v/swarmauri_tool_jupyterexportpython?label=swarmauri_tool_jupyterexportpython&color=green" alt="PyPI - swarmauri_tool_jupyterexportpython"/></a>
</p>
---
# Swarmauri Tool Jupyter Export Python
Exports a Jupyter `NotebookNode` to a Python script using nbconvert’s `PythonExporter` with optional custom templates.
## Features
- Accepts a notebook object (`nbformat.NotebookNode`) and returns the rendered `.py` source.
- Supports passing an nbconvert template for custom formatting.
- Returns `{"exported_script": ...}` on success or `{"error": ...}` on failure.
## Prerequisites
- Python 3.10 or newer.
- nbconvert/nbformat installed (pulled automatically).
## Installation
```bash
# pip
pip install swarmauri_tool_jupyterexportpython
# poetry
poetry add swarmauri_tool_jupyterexportpython
# uv (pyproject-based projects)
uv add swarmauri_tool_jupyterexportpython
```
## Quickstart
```python
import nbformat
from swarmauri_tool_jupyterexportpython import JupyterExportPythonTool
notebook = nbformat.read("notebooks/example.ipynb", as_version=4)
exporter = JupyterExportPythonTool()
result = exporter(notebook, template_file=None)
if "exported_script" in result:
Path("notebooks/example.py").write_text(result["exported_script"], encoding="utf-8")
else:
print("Error:", result["error"])
```
## Tips
- Use custom templates to control cell separators or code comments—pass a `.tpl` file via `template_file`.
- Pair with notebook execution tools (execute → export to .py) to operationalize notebooks as Python scripts.
## Want to help?
If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
| text/markdown | Jacob Stewart | jacob@swarmauri.com | null | null | null | swarmauri, tool, jupyterexportpython, exports, jupyter, notebook, script, nbconvert, pythonexporter, facilitating, code, extraction, python | [
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Natural Language :: English",
"Development Status :: 3 - Alpha",
"Intended Audi... | [] | null | null | <3.13,>=3.10 | [] | [] | [] | [
"nbconvert>=7.16.6",
"swarmauri_base",
"swarmauri_core",
"swarmauri_standard"
] | [] | [] | [] | [] | 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-18T09:50:30.561590 | swarmauri_tool_jupyterexportpython-0.9.3.dev5-py3-none-any.whl | 9,027 | 08/98/6de5be9e8150066be5c02db0d4692c9cbf8284fdaf42f0cafa214c86ccc9/swarmauri_tool_jupyterexportpython-0.9.3.dev5-py3-none-any.whl | py3 | bdist_wheel | null | false | e641128639c65d34b60b0cfe97f213e7 | b5539717352059e52bac5e5733fbe084682eca459680a6d3c5b6984ddc4b1b4b | 08986de5be9e8150066be5c02db0d4692c9cbf8284fdaf42f0cafa214c86ccc9 | Apache-2.0 | [
"LICENSE"
] | 0 |
2.4 | coordinator-node | 0.1.7 | Runtime engine for Crunch coordinator nodes | # coordinator-node
[](https://pypi.org/project/coordinator-node/)
Runtime engine for Crunch coordinator nodes. Powers the full competition pipeline — from data ingestion through scoring to on-chain emission checkpoints.
```bash
pip install coordinator-node
```
---
## Two ways to use this repo
### 1. Scaffold a new competition (recommended)
Use the Crunch CLI to create a self-contained workspace that pulls `coordinator-node` from PyPI:
```bash
crunch-cli init-workspace my-challenge
cd my-challenge
make deploy
```
This creates:
```
my-challenge/
├── node/ ← docker-compose, config, scripts (uses coordinator-node from PyPI)
├── challenge/ ← participant-facing package (tracker, scoring, examples)
└── Makefile
```
### 2. Develop the engine itself
Clone this repo to work on the `coordinator_node` package directly:
```bash
git clone https://github.com/crunchdao/coordinator-node-starter.git
cd coordinator-node-starter
uv sync
make deploy # uses local coordinator_node/ via COPY in Dockerfile
```
Changes to `coordinator_node/` are picked up immediately on rebuild.
---
## Architecture
### Pipeline
```
Feed → Input → Prediction → Score → Snapshot → Checkpoint → On-chain
```
### Workers
| Worker | Purpose |
|---|---|
| `feed-data-worker` | Ingests feed data (Pyth, Binance, etc.) via polling + backfill |
| `predict-worker` | Gets latest data → ticks models → collects predictions |
| `score-worker` | Resolves actuals → scores predictions → writes snapshots → rebuilds leaderboard |
| `checkpoint-worker` | Aggregates snapshots → builds EmissionCheckpoint for on-chain submission |
| `report-worker` | FastAPI server: leaderboard, predictions, feeds, snapshots, checkpoints |
### Feed Dimensions
| Dimension | Example | Env var |
|---|---|---|
| `source` | pyth, binance | `FEED_SOURCE` |
| `subject` | BTC, ETH | `FEED_SUBJECTS` |
| `kind` | tick, candle | `FEED_KIND` |
| `granularity` | 1s, 1m | `FEED_GRANULARITY` |
### Status Lifecycles
```
Input: RECEIVED → RESOLVED
Prediction: PENDING → SCORED / FAILED / ABSENT
Checkpoint: PENDING → SUBMITTED → CLAIMABLE → PAID
```
---
## Configuration
All configuration is via environment variables. Copy the example env file to get started:
```bash
cp .local.env.example .local.env
```
Key variables:
| Variable | Description | Default |
|---|---|---|
| `CRUNCH_ID` | Competition identifier | `starter-challenge` |
| `FEED_SOURCE` | Data source | `pyth` |
| `FEED_SUBJECTS` | Assets to track | `BTC` |
| `SCORING_FUNCTION` | Dotted path to scoring callable | `coordinator_node.extensions.default_callables:default_score_prediction` |
| `CHECKPOINT_INTERVAL_SECONDS` | Seconds between checkpoints | `604800` |
| `MODEL_BASE_CLASSNAME` | Participant model base class | `tracker.TrackerBase` |
| `MODEL_RUNNER_NODE_HOST` | Model orchestrator host | `model-orchestrator` |
---
## API Security
Endpoints are protected by API key authentication when `API_KEY` is set. Off by default for backward compatibility.
### Quick start
```bash
# In .local.env
API_KEY=my-strong-secret
```
After `make deploy`, admin endpoints require the key:
```bash
# Rejected (401)
curl -s http://localhost:8000/reports/backfill
# Accepted
curl -s -H "X-API-Key: my-strong-secret" http://localhost:8000/reports/backfill
```
### Endpoint tiers
| Tier | Default prefixes | Auth required |
|------|-----------------|---------------|
| **Public** | `/healthz`, `/reports/leaderboard`, `/reports/schema`, `/reports/models`, `/reports/feeds`, `/info`, `/docs` | Never |
| **Read** | `/reports/predictions`, `/reports/snapshots`, `/data/backfill/*` | Only if `API_READ_AUTH=true` |
| **Admin** | `/reports/backfill` (POST), `/reports/checkpoints/`, `/custom/*` | Always (when API_KEY set) |
### Sending the key
Three methods (any one works):
```bash
# X-API-Key header (recommended)
curl -H "X-API-Key: <key>" ...
# Authorization: Bearer header
curl -H "Authorization: Bearer <key>" ...
# Query parameter (for quick testing only)
curl "...?api_key=<key>"
```
### Configuration
| Env var | Default | Description |
|---------|---------|-------------|
| `API_KEY` | _(empty)_ | Shared secret. When unset, all endpoints are open. |
| `API_READ_AUTH` | `false` | When `true`, read endpoints also require the API key. |
| `API_PUBLIC_PREFIXES` | See above | Comma-separated prefixes that never require auth. |
| `API_ADMIN_PREFIXES` | See above | Comma-separated prefixes that always require auth. |
### Custom `api/` endpoints
Custom endpoints under `/custom/` are **admin-tier by default** — they require the API key when set. To make a custom endpoint public, add its prefix to `API_PUBLIC_PREFIXES`.
---
## Custom API Endpoints
Add endpoints to the report worker by dropping Python files in `node/api/`:
```python
# node/api/my_endpoints.py
from fastapi import APIRouter
router = APIRouter(prefix="/custom", tags=["custom"])
@router.get("/hello")
def hello():
return {"message": "Hello from custom endpoint"}
```
After `make deploy`, available at `http://localhost:8000/custom/hello`.
Any `.py` file in `api/` with a `router` attribute (a FastAPI `APIRouter`) is auto-mounted at startup. Files starting with `_` are skipped.
Full database access is available via the same dependency injection pattern:
```python
from typing import Annotated
from fastapi import APIRouter, Depends
from sqlmodel import Session
from coordinator_node.db import create_session, DBModelRepository
router = APIRouter(prefix="/custom")
def get_db_session():
with create_session() as session:
yield session
@router.get("/models/count")
def model_count(session: Annotated[Session, Depends(get_db_session)]):
return {"count": len(DBModelRepository(session).fetch_all())}
```
| Env var | Default | Description |
|---------|---------|-------------|
| `API_ROUTES_DIR` | `api/` | Directory to scan for router files |
| `API_ROUTES` | _(empty)_ | Comma-separated `module:attr` paths for explicit imports |
---
## Extension Points
Customize competition behavior by setting callable paths in your env:
| Env var | Purpose |
|---|---|
| `SCORING_FUNCTION` | Score a prediction against ground truth |
| `INFERENCE_INPUT_BUILDER` | Transform raw feed data into model input |
| `INFERENCE_OUTPUT_VALIDATOR` | Validate model output shape/values |
| `MODEL_SCORE_AGGREGATOR` | Aggregate per-model scores across predictions |
| `LEADERBOARD_RANKER` | Custom leaderboard ranking strategy |
---
## CrunchConfig
All type shapes and behavior are defined in a single `CrunchConfig`. Workers auto-discover the operator's config at startup:
```python
from coordinator_node.crunch_config import CrunchConfig, EnsembleConfig
contract = CrunchConfig(
# Type shapes
raw_input_type=RawInput,
output_type=InferenceOutput,
score_type=ScoreResult,
scope=PredictionScope(),
aggregation=Aggregation(),
# Multi-metric scoring (default: 5 active metrics)
metrics=["ic", "ic_sharpe", "hit_rate", "max_drawdown", "model_correlation"],
# Ensemble (default: off)
ensembles=[],
# Callables
resolve_ground_truth=default_resolve_ground_truth,
aggregate_snapshot=default_aggregate_snapshot,
build_emission=default_build_emission,
)
```
### Config resolution order
All workers use `load_config()` which tries, in order:
1. `CRUNCH_CONFIG_MODULE` env var (e.g. `my_package.crunch_config:MyCrunchConfig`)
2. `runtime_definitions.crunch_config:CrunchConfig` — the standard operator override
3. `runtime_definitions.contracts:CrunchConfig` — backward compat
4. `coordinator_node.crunch_config:CrunchConfig` — engine default
The operator's config is imported automatically — no env var needed if `runtime_definitions/crunch_config.py` exists on `PYTHONPATH` (it does in the Docker setup).
---
## Multi-Metric Scoring
Every score cycle computes portfolio-level metrics alongside the per-prediction scoring function. Metrics are stored in snapshot `result_summary` JSONB and surfaced on the leaderboard.
### Active metrics
Set in the contract — only listed metrics are computed:
```python
# Use all defaults (ic, ic_sharpe, hit_rate, max_drawdown, model_correlation)
contract = CrunchConfig()
# Opt out entirely — per-prediction scoring only
contract = CrunchConfig(metrics=[])
# Pick specific metrics
contract = CrunchConfig(metrics=["ic", "sortino_ratio", "turnover"])
```
### Built-in metrics
| Tier | Name | Description |
|------|------|-------------|
| T1 | `ic` | Information Coefficient — Spearman rank correlation vs. actual returns |
| T1 | `ic_sharpe` | mean(IC) / std(IC) — rewards consistency |
| T1 | `mean_return` | Mean return of a long-short portfolio from signals |
| T1 | `hit_rate` | % of predictions with correct directional sign |
| T1 | `model_correlation` | Mean pairwise correlation against other models |
| T2 | `max_drawdown` | Worst peak-to-trough on cumulative score |
| T2 | `sortino_ratio` | Sharpe but only penalizes downside |
| T2 | `turnover` | Signal change rate between consecutive predictions |
| T3 | `fnc` | Feature-Neutral Correlation (ensemble-aware) |
| T3 | `contribution` | Leave-one-out ensemble contribution |
| T3 | `ensemble_correlation` | Correlation to ensemble output |
T3 metrics require ensembling to be enabled.
### Custom metrics
Register your own metric function:
```python
from coordinator_node.metrics import get_default_registry
def my_custom_metric(predictions, scores, context):
"""Return a single float."""
return some_computation(predictions, scores)
get_default_registry().register("my_custom", my_custom_metric)
# Then add it to the contract
contract = CrunchConfig(metrics=["ic", "my_custom"])
```
### Ranking by any metric
The leaderboard can rank by any active metric. Set `ranking_key` to a metric name:
```python
contract = CrunchConfig(
metrics=["ic", "ic_sharpe", "hit_rate"],
aggregation=Aggregation(ranking_key="ic_sharpe"),
)
```
---
## Ensemble Framework
Combine multiple model predictions into virtual meta-models. Off by default — opt in via the contract.
### Quick start
```python
from coordinator_node.crunch_config import CrunchConfig, EnsembleConfig
from coordinator_node.services.ensemble import inverse_variance, equal_weight, top_n
contract = CrunchConfig(
ensembles=[
EnsembleConfig(name="main", strategy=inverse_variance),
EnsembleConfig(name="top5", strategy=inverse_variance, model_filter=top_n(5)),
EnsembleConfig(name="equal", strategy=equal_weight),
],
)
```
### How it works
1. After scoring, the score worker computes ensembles for each enabled config
2. Models are filtered (optional `model_filter`)
3. Weights computed via `strategy(model_metrics, predictions) → {model_id: weight}`
4. Weighted-average predictions stored as `PredictionRecord` with `model_id="__ensemble_{name}__"`
5. Virtual models are scored, metrics computed, and appear in leaderboard data
### Built-in strategies
| Strategy | Description |
|----------|-------------|
| `inverse_variance` | Weight = 1/var(predictions), normalized. Default. |
| `equal_weight` | 1/N for all included models. |
### Model filters
```python
from coordinator_node.services.ensemble import top_n, min_metric
# Keep only top 5 by score
EnsembleConfig(name="top5", model_filter=top_n(5))
# Keep models with IC > 0.03
EnsembleConfig(name="quality", model_filter=min_metric("ic", 0.03))
```
### Leaderboard filtering
Ensemble virtual models are hidden from the leaderboard by default. Toggle with:
```
GET /reports/leaderboard?include_ensembles=true
GET /reports/models/global?include_ensembles=true
GET /reports/models/params?include_ensembles=true
```
### Contribution-aware rewards
The default `build_emission` uses tier-based ranking. For competitions that want to incentivize diversity, switch to `contribution_weighted_emission`:
```python
from coordinator_node.extensions.emission_strategies import contribution_weighted_emission
config = CrunchConfig(
build_emission=contribution_weighted_emission,
metrics=["ic", "ic_sharpe", "hit_rate", "model_correlation", "contribution"],
ensembles=[EnsembleConfig(name="main")],
)
```
This blends three factors into reward allocation:
- **Rank** (50%): inverse rank — higher-ranked models get more
- **Contribution** (30%): ensemble contribution — models that improve the ensemble get more
- **Diversity** (20%): 1 - model_correlation — unique signals get more
Weights are configurable: `contribution_weighted_emission(..., rank_weight=0.3, contribution_weight=0.5, diversity_weight=0.2)`.
### Ensemble signal endpoint
Activate the built-in ensemble signal API by renaming:
```bash
mv node/api/ensemble_signals.py.disabled node/api/ensemble_signals.py
make deploy
```
Endpoints:
```
GET /signals/ensemble → list available ensembles
GET /signals/ensemble/{name} → latest ensemble prediction (the product)
GET /signals/ensemble/{name}/history → recent prediction history
```
### Diversity feedback for competitors
Competitors can see how their model relates to the collective:
```
GET /reports/models/{model_id}/diversity
```
Returns:
```json
{
"model_id": "my_model",
"rank": 3,
"diversity_score": 0.75,
"metrics": {
"ic": 0.035,
"model_correlation": 0.25,
"ensemble_correlation": 0.60,
"contribution": 0.02,
"fnc": 0.03
},
"guidance": [
"Low correlation + positive IC — your model provides unique alpha."
]
}
```
The backtest harness also surfaces diversity metrics:
```python
result = BacktestRunner(model=MyTracker()).run(...)
result.summary() # includes diversity section when model_id is set
result.diversity # fetches live diversity feedback from coordinator
```
---
## Report API
| Endpoint | Params | Description |
|---|---|---|
| `GET /reports/leaderboard` | `include_ensembles` (bool, default false) | Current leaderboard |
| `GET /reports/models` | | Registered models |
| `GET /reports/models/global` | `projectIds`, `start`, `end`, `include_ensembles` | Global model scores |
| `GET /reports/models/params` | `projectIds`, `start`, `end`, `include_ensembles` | Per-scope model scores |
| `GET /reports/predictions` | `projectIds`, `start`, `end` | Prediction history |
| `GET /reports/feeds` | | Active feed subscriptions |
| `GET /reports/models/{id}/diversity` | | Diversity feedback: correlation, contribution, guidance |
| `GET /reports/diversity` | `limit` | All models' diversity scores for dashboard chart |
| `GET /reports/ensemble/history` | `ensemble_name`, `since`, `until`, `limit` | Ensemble metrics over time |
| `GET /reports/checkpoints/rewards` | `model_id`, `limit` | Reward distribution per checkpoint |
| `GET /reports/snapshots` | `model_id`, `since`, `until`, `limit` | Per-model period summaries (enriched with metrics) |
| `GET /reports/checkpoints` | `status`, `limit` | Checkpoint history |
| `GET /reports/checkpoints/{id}/emission` | | Raw emission (frac64) |
| `GET /reports/checkpoints/{id}/emission/cli-format` | | CLI JSON format |
| `GET /reports/emissions/latest` | | Latest emission |
| `POST /reports/checkpoints/{id}/confirm` | `tx_hash` | Record tx_hash |
| `PATCH /reports/checkpoints/{id}/status` | `status` | Advance status |
### Backfill & Data
| Endpoint | Description |
|---|---|
| `GET /reports/backfill/feeds` | Configured feeds eligible for backfill |
| `POST /reports/backfill` | Start a backfill job (409 if one running) |
| `GET /reports/backfill/jobs` | List all backfill jobs |
| `GET /reports/backfill/jobs/{id}` | Job detail with progress percentage |
| `GET /data/backfill/index` | Manifest of available parquet files |
| `GET /data/backfill/{source}/{subject}/{kind}/{granularity}/{file}` | Download parquet file |
---
## Backfill & Backtest
### Coordinator-side backfill
Backfill historical data from the UI or API:
1. Admin triggers backfill via `POST /reports/backfill` (or the UI)
2. Data is fetched from the configured feed provider (Binance, Pyth, etc.)
3. Written to Hive-partitioned parquet files: `data/backfill/{source}/{subject}/{kind}/{granularity}/YYYY-MM-DD.parquet`
4. Progress tracked in `backfill_jobs` table (resumable on restart)
5. Parquet files served via `/data/backfill/` endpoints for model consumption
### Competitor-side backtest
The challenge package includes a backtest harness. Competitors run backtests locally — model code is identical to production:
```python
from starter_challenge.backtest import BacktestRunner
from my_model import MyTracker
result = BacktestRunner(model=MyTracker()).run(
start="2026-01-01", end="2026-02-01"
)
result.predictions_df # DataFrame in notebook
result.metrics # rolling windows + multi-metric enrichment
result.summary() # formatted output
# result.metrics example:
# {
# 'score_recent': 0.42, 'score_steady': 0.38, 'score_anchor': 0.35,
# 'ic': 0.035, 'ic_sharpe': 1.2, 'hit_rate': 0.58,
# 'mean_return': 0.012, 'max_drawdown': -0.08, 'sortino_ratio': 1.5,
# 'turnover': 0.23,
# }
```
- Data auto-fetched from coordinator and cached locally on first run
- Coordinator URL and feed dimensions baked into challenge package
- Same `tick()` → `predict()` loop as production
- Same scoring function, rolling window metrics, and multi-metric evaluation as leaderboard
---
## Emission Checkpoints
Checkpoints produce `EmissionCheckpoint` matching the on-chain protocol:
```json
{
"crunch": "<pubkey>",
"cruncher_rewards": [{"cruncher_index": 0, "reward_pct": 350000000}],
"compute_provider_rewards": [],
"data_provider_rewards": []
}
```
`reward_pct` uses frac64 (1,000,000,000 = 100%).
---
## Database Tables
### Feed layer
| Table | Purpose |
|---|---|
| `feed_records` | Raw data points from external sources. Keyed by `(source, subject, kind, granularity, ts_event)`. Values and metadata stored as JSONB. |
| `feed_ingestion_state` | Tracks the last ingested timestamp per feed scope to enable incremental polling and backfill. |
### Backfill layer
| Table | Purpose |
|---|---|
| `backfill_jobs` | Tracks backfill runs. Status: `pending → running → completed / failed`. Stores cursor for resume, records written, pages fetched. |
Historical backfill data is stored as Hive-partitioned parquet files at `data/backfill/{source}/{subject}/{kind}/{granularity}/YYYY-MM-DD.parquet` (not in Postgres).
### Pipeline layer
| Table | Purpose |
|---|---|
| `inputs` | Incoming data events. Status: `RECEIVED → RESOLVED`. Holds raw data, actuals (once known), and scope metadata. |
| `predictions` | One row per model per input. Links to a `scheduled_prediction_config`. Stores inference output, execution time, and resolution timestamp. Status: `PENDING → SCORED / FAILED / ABSENT`. |
| `scores` | One row per scored prediction. Stores the result payload, success flag, and optional failure reason. |
| `snapshots` | Per-model period summaries. Aggregates prediction counts and result metrics over a time window. |
| `checkpoints` | Periodic emission checkpoints. Aggregates snapshots into on-chain reward distributions. Status: `PENDING → SUBMITTED → CLAIMABLE → PAID`. |
| `scheduled_prediction_configs` | Defines when and what to predict — scope template, schedule, and ordering. Seeded at init from `scheduled_prediction_configs.json`. |
### Model layer
| Table | Purpose |
|---|---|
| `models` | Registered participant models. Tracks overall and per-scope scores as JSONB. |
| `leaderboards` | Point-in-time leaderboard snapshots with ranked entries as JSONB. |
---
## Local Development
```bash
# Run tests
uv run pytest tests/ -x -q
# Start all services locally
make deploy
# View logs
make logs
# Tear down
make down
```
---
## Project Structure
```
coordinator-node-starter/
├── coordinator_node/ ← core engine (published to PyPI as coordinator-node)
│ ├── workers/ ← feed, predict, score, checkpoint, report workers
│ ├── services/ ← business logic
│ ├── entities/ ← domain models
│ ├── db/ ← database tables and init
│ ├── feeds/ ← data source adapters (Pyth, Binance, etc.)
│ ├── schemas/ ← API schemas
│ ├── extensions/ ← default callables
│ ├── config/ ← runtime configuration
│ └── contracts.py ← competition shape: types, scope, and callable hooks
├── base/ ← template used by crunch-cli init-workspace
│ ├── node/ ← node template (Dockerfile, docker-compose, config)
│ └── challenge/ ← challenge template (tracker, scoring, backtest, examples)
├── tests/ ← test suite
├── docker-compose.yml ← local dev compose (uses local coordinator_node/)
├── Dockerfile ← local dev Dockerfile (COPYs coordinator_node/)
├── pyproject.toml ← package definition
└── Makefile ← deploy / down / logs / test
```
---
## Publishing
```bash
uv build
twine upload dist/*
```
| text/markdown | null | null | null | null | null | null | [] | [] | null | null | >=3.12 | [] | [] | [] | [
"alembic>=1.13",
"fastapi>=0.100.0",
"model-runner-client>=0.11.0",
"psycopg2-binary>=2.9",
"pyarrow>=15.0",
"python-binance>=1.0",
"requests>=2.28",
"sqlmodel>=0.0.14",
"uvicorn>=0.20"
] | [] | [] | [] | [
"Homepage, https://github.com/crunchdao/coordinator-node-starter",
"Repository, https://github.com/crunchdao/coordinator-node-starter"
] | twine/6.2.0 CPython/3.13.2 | 2026-02-18T09:50:29.084449 | coordinator_node-0.1.7.tar.gz | 285,642 | bf/d9/443fe82058dd97f1adbfd62542be59219085496521d4d87a32d8676f886a/coordinator_node-0.1.7.tar.gz | source | sdist | null | false | af463c12bab4c8276fca6d7e3928ea70 | 101d853e62833df719934e4f27f61b10ed40ebec0f765ecddde3e0e23d4e49bc | bfd9443fe82058dd97f1adbfd62542be59219085496521d4d87a32d8676f886a | MIT | [] | 247 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.