semvec/pypi-packages huggingface dataset:
quicat 0.1.2
QUIck Clonal Analysis Toolkit - quicat
Requires Python: <3.13,>=3.10

# quicat

**qui**ck **C**lonal **A**nalysis **T**oolkit—`quiCAT`—is a toolkit for extracting, and analyzing clonal populations from sequencing data. Designed for flexibility and performance, it simplifies the process genetic barcodes extraction from bulkDNA, single-cell, and spatial transcriptomics datasets.

---

Install with

```bash
pip install quicat
```

- **Documentation** <https://quicat.readthedocs.io/>
async-bash-mcp 0.1.6
A robust subprocess execution MCP
Requires Python: >=3.13

# async-bash-mcp

[![pypi](https://img.shields.io/pypi/v/async-bash-mcp)](https://pypi.org/project/async-bash-mcp/) [![Test](https://github.com/xhuw/async-bash-mcp/actions/workflows/test.yaml/badge.svg)](https://github.com/xhuw/async-bash-mcp/actions/workflows/test.yaml)

An MCP server for spawning and managing bash commands asynchronously. Run multiple shell commands in parallel and check their progress independently.

## Usage with opencode

Add to your `opencode.json` config to replace the bash tool with async-bash-mcp:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "tools": {
    "bash": false
  },
  "mcp": {
    "async-bash": {
      "type": "local",
      "command": ["uvx", "async-bash-mcp"],
      "enabled": true
    }
  }
}
```

Then use commands like:
- "Spawn a long-running build in the background"
- "Run tests in parallel and show me the results"
- "Start a server and tell me when it's ready"

## Why async bash?

When working with long-running commands like builds, tests, or servers, the agent needs to:
- Monitor progress incrementally without committing to a fixed timeout
- Run multiple commands in parallel and check each independently
- Make decisions about continuing or terminating based on partial output
- Process real-time feedback as commands generate output

This tool provides the agent with better information for decision-making, leading to faster task completion and fewer confused responses.

**Key advantages over the built-in bash tool:**
- **Better decision making**: Agents can see partial output and make informed choices about continuing or terminating
- **Parallel execution**: Run multiple commands simultaneously
- **No timeout guessing**: Check progress incrementally instead of setting timeouts upfront
- **Faster iterations**: No waiting for arbitrary timeouts when errors are already visible

This tool is designed to replace opencode's bash tool for any scenario involving potentially long-running commands, giving agents the information they need to make better decisions and save you time.

## Tools

**spawn** - Launch a bash command asynchronously
- `command` (str): The bash command to run
- `cwd` (str, optional): Working directory path
- Returns a process ID for tracking

**list_processes** - Show all running/recent processes
- No parameters
- Returns array of `{"ID": int, "command": str, "done": bool}`

**poll** - Check progress of a spawned process
- `process_id` (int): ID from spawn command
- `wait` (int): Wait time in milliseconds
- `terminate` (bool, optional): Kill process before returning results
- Returns `{"stdout": str, "stderr": str, "elapsedTime": float, "finished": bool, "exitCode": int}`

## Installation

```bash
uvx async-bash-mcp
```
ocfinance 0.0.12
Download on-chain data for bitcoin (works for cryptoquant)
Requires Python: >=3.8

# ocfinance

[![Build Passing](https://github.com/dhruvan2006/ocfinance/actions/workflows/release.yml/badge.svg)](https://github.com/dhruvan2006/ocfinance/actions/workflows/release.yml)
[![Tests Passing](https://github.com/dhruvan2006/ocfinance/actions/workflows/tests.yml/badge.svg)](https://github.com/dhruvan2006/ocfinance/actions/workflows/tests.yml)
[![PyPI - Version](https://img.shields.io/pypi/v/ocfinance)](https://pypi.org/project/ocfinance/)
[![PyPI Downloads](https://static.pepy.tech/badge/ocfinance)](https://pypi.org/project/ocfinance/)
[![GitHub License](https://img.shields.io/github/license/dhruvan2006/ocfinance)](https://github.com/dhruvan2006/ocfinance)

`ocfinance` is a python package that enables you to download on-chain data from various sources, including Cryptoquant, CheckOnChain, etc.

## Features
- **Easy Data Download**: Download on-chain data from various sources with a single line of code.
- **CSV Export**: Save data as CSV files for easy analysis in Excel or other tools.
- **Pandas Integration**: Work with data directly as a pandas DataFrame for simple manipulation and analysis.
- **Customizable Queries**: Specify start and end date parameters.

## Documentation: [https://ocfinance.readthedocs.io/](https://ocfinance.readthedocs.io/)

**Complete documentation is available at:** 
[https://ocfinance.readthedocs.io/](https://ocfinance.readthedocs.io/)

## Supported Websites
- [CheckOnChain](https://charts.checkonchain.com/)
- [ChainExposed](https://chainexposed.com/)
- [Woocharts](https://woocharts.com/)
- [Cryptoquant](https://cryptoquant.com/)
- [Bitbo Charts](https://charts.bitbo.io/)
- [Bitcoin Magazine Pro](https://www.bitcoinmagazinepro.com)
- [Blockchain.com](https://www.blockchain.com/explorer/charts)

## Installation
To install the `ocfinance` package, use pip:
```bash
pip install ocfinance
```

## Quick Start
To download the data of a chart, simply obtain the URL and pass it to the download function

```python
import ocfinance as of

# Download the data from the specified URL
data = of.download("https://charts.checkonchain.com/btconchain/pricing/pricing_picycleindicator/pricing_picycleindicator_light.html")

# Usage examples
# Export as CSV
data.to_csv('out.csv')

# Plot
data.plot()
```

For detailed usage instructions, including how to work with Cryptoquant data and advanced features, please refer to our [documentation](https://ocfinance.readthedocs.io/).
nav-argus-glue 0.8.2
An Argus glue service for Network Administration Visualized
Requires Python: >=3.9
Keywords: api, argus, client

# NAV ↔ Argus glue service
![PyPI](https://img.shields.io/pypi/v/nav-argus-glue?label=PyPI)
![Black](https://img.shields.io/badge/code%20style-black-000000.svg)

This is a glue service for integration between
[Argus](https://github.com/Uninett/Argus), the alert aggregation server, and
[Network Administration Visualized](https://github.com/Uninett/nav) (NAV), the
network monitoring software suite provided by Uninett.

## How it works

`navargus` acts as an export script for the NAV event engine. It accepts
stacked, JSON-serialized alert objects on its STDIN.
The event engine will feed `navargus` a continuous stream of NAV alerts as they
are generated. `navargus` uses these alerts to either create new incidents in
the Argus API, or resolve existing ones as needed.

Refer to the Argus server documentation to learn more about [integrating monitoring
systems](https://argus-server.readthedocs.io/en/latest/integrating-monitoring-systems.html)
with Argus.

## Installation

If you don't want to install from the source code repository, the latest
version of the package is always available on PyPI:

```shell
pip install nav-argus-glue
```

## Configuration

### NAV

Add `navargus` in the `[export]` section of the `eventengine.conf` file.

```ini
[export]
# If set, the script option will point to a program that will receive a
# continuous stream of JSON serialized alert objects on its STDIN.
script = /path/to/navargus
```

### Argus

In the Argus admin interface, create a new "Source system" for your
NAV instance. This will automatically create an Argus user account for
this instance. Now, use the Argus admin interface to create an authentication
token for your user.

### NAV-Argus glue service

`navargus` is configured via `navargus.yml`. Since `navargus` is designed to
run in conjunction with NAV's event engine, this config file must be placed in
NAV's config directory (typically `/etc/nav`).

A minimal `navargus.yml` contains the base URL of your Argus server and the
Argus API token generated above.

An example:

```yml
---
api:
    url: https://argus.example.com/api/v1
    token: very-long-and-secret-string
```

The configuration file may optionally contain a list of tags.
These tags will be added to all incidents created by this NAV instance.
To learn more about tags, refer to
[Argus documentation](https://argus-server.readthedocs.io/).

A full configuration file example is provided in
[navargus.example.yml](navargus.example.yml).

Now, you can run the command `navargus --test-api` to verify that the glue
service is properly configured and able to query the Argus API.

## Code style

This module uses Black as a source code formatter for Python code.

A pre-commit hook will format new code automatically before committing.
To enable this pre-commit hook, run

```console
$ pre-commit install
```
KanvasObjectKlick 0.2.0
Allows you to visualize objects with html on a 2D canvas with the desired color, caption (on hover), and image of the object (on click). 
Requires Python: >=3.7

# KanvasObjectKlick

KanvasObjectKlick allows you to visualize objects with html on a 2D canvas with the desired color, caption (on hover), and image of the object (on click).

# Installation

```bash
python3 -m pip install --upgrade pip
pip3 install KanvasObjectKlick
```

# Usage

```python
import random
from KanvasObjectKlick import KOKEntity, build_a


keks = []
for i in range(random.randint(3, 50)):
    # name/description of object. It will be displayed when the mouse cursor is hovered over.
    name_i = f"name_{i}"
    
    # x and y, can be float and any range
    coords_i = (random.randint(-1000, 1000)+random.random(), random.randint(-1000, 1000)+random.random())  
    
    # RGB color
    color_i = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))  
    
    # instead of None you can use Pillow, OpenCV image or just path to picture file
    img_i = None  
    
    # Just create KOKEntity
    kok = KOKEntity(name=name_i, coords=coords_i, color=color_i, img=img_i)
    
    keks.append(kok)

# It will create `/path/to/out/file.html` file. Just open it in your browser.
build_a(keks, "/path/to/out/file", zip_need=False)
```

You can also create zip file with `zip_need=True`. In this case, file `/path/to/out/file.zip` will be created.

Instead `build_a` you can use `build_b` (`from KanvasObjectKlick import build_b`). It will create zip with no all in one file. This can be useful when there are too many objects (or rather their images).

```python
# ...

from KanvasObjectKlick import build_b

# It will create `/path/to/out/file.zip` file. Just extract it and open `index.html` in your browser.
build_b(keks, "/path/to/out/file", "/path/to/working/dir")
```

`/path/to/working/dir` can be any directory. It is needed in order to stack temporary files while working. In the end, there will be no garbage left, everything superfluous will be removed.
qelrix 0.0.1
A simple library for interacting with Gemini API
Requires Python: >=3.6

# Qelrix

Qelrix is a simple Python library for interacting with the Gemini API.

## Installation

```bash
pip install qelrix
```

## Usage

```python
import qelrix

qelrix.apikey("YOUR_API_KEY")
qelrix.model("YOUR_GEMINI_ENDPOINT")
qelrix.hoi("Hello, how are you?")
print(qelrix.traloi())
```

## API

### `qelrix.apikey(key: str) -> str`
Sets the API key.

### `qelrix.model(url: str) -> str`
Sets the full Gemini API endpoint URL.

### `qelrix.hoi(text: str)`
Sends a question to the API and stores the response.

### `qelrix.traloi() -> str`
Retrieves the answer from the last `hoi()` call.
py-dbt-cll 0.1.3
python package to extract CLL from dbt files
Requires Python: <3.12,>=3.9

### py-dbt-cll

![PyPI version](https://img.shields.io/pypi/v/py-dbt-cll.svg)&nbsp;![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/ngmiduc/py-dbt-cll?label=version)&nbsp;![Publish](https://github.com/ngmiduc/py-dbt-cll/actions/workflows/publish.yml/badge.svg)&nbsp;![Tests](https://github.com/ngmiduc/py-dbt-cll/actions/workflows/test.yml/badge.svg)

Python packages that extracts column lineage information from dbt models based on their metadata in the manifest file. It does not require any connection to the database and it only uses sqlGlot to extract the column level lineage information from a SQL query. Before the query is passed into sqlGlot, the query is modified with additional information from the manifest file, so that the column lineage can be accurately determined.

### Installation

You can install the package using pip:

```bash
pip install py-dbt-cll
```

### Usage

Import the class from the module.

```bash
from py_dbt_cll.dbt_lineage import DbtCLL
```

Load your manifest file from the json file and create the class instance with it. After that you can use the method `extract_cll` to extract column lineage information from your SQL queries.

```py
with open("tests/manifest.json", "r", encoding="utf-8") as file:
    manifest_data = json.load(file)
ccl = DbtCLL(manifest_data)

sql = """
    select *
    from (
        select *
        from ...
    ) as final
"""
columns = ["academic_year_id", "date_id"]
lineage = ccl.extract_cll(sql, columns, debug=False)
```

Parameters:

- `sql` (str): The SQL query from which to extract column lineage.
- `columns` (list): A list of column names to extract lineage for.
- `debug` (bool): Whether to enable debug mode for more verbose output. (default is False)
- `dialect` (str): The SQL dialect to use for parsing the SQL query (default is "tsql").

Returns:

- dict: A dictionary mapping column names to their lineage information.