semvec/pypi-packages huggingface dataset:
proliferate-ai 0.2.2
Proliferate Error Monitoring SDK for Python
Requires Python: >=3.9
Keywords: error-monitoring, error-tracking, exception-handling, proliferate

# proliferate-ai

Python SDK for Proliferate Error Monitoring.

## Installation

```bash
pip install proliferate-ai
```

## Quick Start

```python
import proliferate

# Initialize the SDK
proliferate.init(
    api_key="pk_your_api_key",
    environment="production",
    release="1.0.0",
)

# Set user context (optional)
proliferate.set_user(id="user_123", email="user@example.com")
```

## Automatic Error Capture

After initialization, the SDK automatically captures:

- Uncaught exceptions (`sys.excepthook`)
- Unhandled exceptions in threads (`threading.excepthook`)

## Manual Error Capture

```python
try:
    risky_operation()
except Exception as e:
    proliferate.capture_exception(e)
```

## FastAPI Integration

```bash
pip install proliferate-ai[fastapi]
```

```python
from fastapi import FastAPI
import proliferate
from proliferate.integrations.fastapi import ProliferateMiddleware

proliferate.init(
    api_key="pk_your_api_key",
    environment="production",
    release="1.0.0",
)

app = FastAPI()
app.add_middleware(ProliferateMiddleware)
```

## Documentation

See [docs.proliferate.dev/sdk/python](https://docs.proliferate.dev/sdk/python) for full documentation.
waapi-client 0.8.1
Wwise Authoring API client.
Requires Python: >=3.10
Keywords: waapi, wwise, audiokinetic

# Wwise Authoring API (Waapi) Client for Python
Decoupled autobahn WAMP client with support for plain options and bindable subscription callbacks.

## Requirements
* Non-EOL Python 3.x version (see `tox.ini` for versions tested). Refer to the official [Status of Python versions](https://devguide.python.org/versions)
* [Wwise](https://www.audiokinetic.com/en/download) instance with the Wwise Authoring API enabled (`Project > User Preferences... > Enable Wwise Authoring API`)

## Setup
On Windows, it is recommended to use the [Python Launcher for Windows](https://docs.python.org/3/using/windows.html#launcher) which is installed with Python 3 from [python.org](https://www.python.org).

* Windows: `py -3 -m pip install waapi-client`
* Other platforms: `python3 -m pip install waapi-client`

## Usage
```python
from waapi import WaapiClient

with WaapiClient() as client:
    result = client.call("ak.wwise.core.getInfo")
```

The `with` statement automatically closes the connection and unregisters subscribers.
To keep the connection alive, instantiate `WaapiClient` and call `disconnect` when you are done.

```python
from waapi import WaapiClient

# Connect (default URL)
client = WaapiClient()

# RPC
result = client.call("ak.wwise.core.getInfo")

# Subscribe
handler = client.subscribe(
    "ak.wwise.core.object.created",
    lambda object: print("Object created: " + str(object))
)

# Bind a different callback at any time
def my_callback(object):
    print("Different callback: " + str(object))

handler.bind(my_callback)

# Unsubscribe
handler.unsubscribe()

# Disconnect
client.disconnect()
```

Be aware that failing to call `disconnect` will result in the program to appear unresponsive, as the background thread
running the connection will remain active.

## Contribute
This repository accepts pull requests.
You may open an [issue](https://github.com/audiokinetic/waapi-client-python/issues) for any bugs or improvement requests.

### Local Install
You may install the package locally using either pip or pipenv.

Clone this repository, then from the repository root run:

* Windows: `py -3 -m pip install -e .`
* Other platforms: `python3 -m pip install -e .`

or

`pipenv install --three`

### Running the Tests
Install the `tox` package:

* Windows: `py -3 -m pip install tox`
* Other platforms: `python3 -m pip install tox`

Open a blank project in Wwise, then you may execute `tox` in the terminal from the root of the repository

The test suite will run for all supported versions of Python.
Use `-e pyXX` to run for a single version, e.g., `tox -e py312` for Python 3.12).
gpt-token-tracker 0.5.0
Token usage and cost tracking for OpenAI responses (another AI providers in future)
Requires Python: >=3.11

Supports OpenAI GPT, Google Gemini, Anthropic Claude and xAI Grok APIs

To install:

```shell
pip install gpt-token-tracker
```

Examples:
```python
from gpt_token_tracker.token_logger import TokenLogger
from gpt_token_tracker.writers.log_writer import LogWriter
from gpt_token_tracker.pricing import PricingRealtime

log_writer = LogWriter("realtime_tokens")   ### Name of logger
realtime_costs = {
        "text_in": 0.60,
        "cached_text_in": 0.06,
        "text_out": 2.40,
        "audio_in": 10.00,
        "audio_out": 20.00,
        "image_in": 5.00,
        "cached_image_in": 0.50,
        "cached_audio_in": 0.40,
    }
token_logger = TokenLogger(log_writer, PricingRealtime(realtime_costs))

token_logger_realtime.record(realtime_model, realtime_result, fake_realtime_usage)

MODEL_NAME = "gpt-realtime-mini"
response = ...
realtime_result = "This is a fake realtime result"
usage = response.usage
token_logger.record(MODEL_NAME, realtime_result, usage)
```


```python
from gpt_token_tracker.token_logger import TokenLogger
from gpt_token_tracker.writers.csv_writer import CSVWriter
from gpt_token_tracker.pricing import PricingTextCompletion

csv_writer = CSVWriter("completion_usage.csv")
text_completion_costs = {
        "text_in": 0.25,
        "cached_text_in": 0.025,
        "text_out": 2.00,
    }
csv_token_logger = TokenLogger(csv_writer, PricingTextCompletion(text_completion_costs))

MODEL_NAME = "gpt-5-mini"

response = ...
completion_result = "This is a fake completion result"
usage = response.usage
csv_token_logger.record(MODEL_NAME, completion_result, usage)
```

```python
from gpt_token_tracker.token_logger import TokenLogger
from gpt_token_tracker.writers.csv_writer import CSVWriter
from gpt_token_tracker.pricing_gemini import PricingGemini

csv_writer = CSVWriter("gemini_usage.csv")
costs = {
        "text_in": 0.10,
        "image_in": 0.10,
        "video_in": 0.10,
        "audio_in": 0.30,
        "cached_text_in": 0.01,
        "cached_video_in": 0.01,
        "cached_image_in": 0.01,
        "cached_audio_in": 0.03,
        "text_out": 0.40,
        "audio_out": 0.40,
        "thinking": 0.40
    }


csv_token_logger = TokenLogger(csv_writer, PricingGemini(costs))

MODEL_NAME = "gemini-2.5-flash-native-audio"

response = ...
result = "This is a fake completion result"
usage = ...
csv_token_logger.record(MODEL_NAME, result, usage)
```

To run tests:
```shell
python -m pip install -r requirements.txt -r requirements_tests.txt --upgrade
python -m pytest tests
```
snakemake-logger-plugin-snkmt 0.1.6
Snakemake logger plugin that writes logs to SQLite database.
Requires Python: <4.0,>=3.11

# Snakemake Logger Plugin: snkmt

**This plugin is still under development and thus may not be fully stable or feature-complete. Use it at your own discretion and report any issues or suggestions to the repository's issue tracker.**

## Introduction

This is the logging plugin for use with [snkmt](https://github.com/cademirch/snkmt), a monitoring tool for Snakemake workflows. Please refer to [snkmt's](https://github.com/cademirch/snkmt) documentation for more details.

## Usage
1. Install via pip: `pip install snakemake-logger-plugin-snkmt`
2. Run Snakemake with the `--logger snkmt` option to enable the snkmt logger. 

>Note: Regular Snakemake logs will continue to be written to stderr when using this plugin, so it may appear that the plugin is not doing anything. This behavior will change in future versions.

## Options
- `--logger-snkmt-db </path/to/sqlite.db>"` Where to write the snkmt DB.

## Development

This project uses [pixi](https://pixi.sh/) for environment management.

### Setting up the development environment

1. Clone the repository:
   ```bash
   git clone https://github.com/cademirch/snakemake-logger-plugin-snkmt.git
   cd snakemake-logger-plugin-snkmt
   ```

2. Install dependencies using pixi:
   ```bash
   pixi install
   ```

3. Activate the development environment:
   ```bash
   pixi shell -e dev
   ```

### Available development tasks

Run these commands with `pixi run` (or just use the command directly if you're in a pixi shell):

- **Quality control**: `pixi run qc` - Runs formatting, linting, and type checking
- **Testing**: `pixi run test` - Runs pytest with coverage reporting
- **Demo**: `pixi run demo` - Runs a demonstration Snakemake workflow using the plugin
- **Individual QC tasks**:
  - `pixi run format` - Format code with ruff
  - `pixi run lint` - Lint code with ruff
  - `pixi run type-check` - Type check with mypy

### Testing the plugin

To test the plugin with a real Snakemake workflow, use the demo task:

```bash
pixi run demo
```

This will:
1. Run a simple Snakemake workflow in `tests/demo/` using the snkmt logger
2. Create a SQLite database at `tests/demo/snkmt.db` with the logged workflow data
3. Clean up the demo directory afterward

You can also run the demo manually without cleanup using:
```bash
pixi run snk_demo
```

## License

This project is licensed under the MIT License. See the `LICENSE` file for details.
markus-autotest-helpers-sql 0.1.0
Helper functions and classes for executing python unit tests that require interaction with a postgres database
Requires Python: >=3.9

# SQL Helper

Helper functions and classes for executing python unit tests that require interaction with a postgres database.

See [function/class docstrings](./src/markus_autotest_helpers_sql/__init__.py) for more information.

## Installation:

```shell
pip install markus-autotest-helpers-sql
```
audiofeatures 0.1.6
Extract MFCC, spectral, and pitch features from audio files

# audiofeatures

**audiofeatures** is a lightweight Python library for extracting features from `.wav` audio files using **librosa**.
It can extract **MFCCs, spectral features, and pitch** for machine learning or audio analysis tasks.

---

## Features

- Extract **MFCC mean and standard deviation** (13 coefficients)  
- Compute **Zero Crossing Rate (ZCR)**  
- Compute **RMS energy**  
- Compute **Spectral features**: centroid, bandwidth, rolloff, contrast  
- Compute **pitch mean and standard deviation**  
- Returns results as a **pandas DataFrame**

---

## Installation

```
pip install audiofeatures
```

---

## Usage

### Extract audio features from a single file

```
from audiofeatures import extract_audio_features

df = extract_audio_features("sample.wav")
print(df.head())
```

---

## Example Output

The `extract_audio_features()` function returns a **pandas DataFrame** with columns like:

```
mfcc_mean_1, mfcc_mean_2, ..., mfcc_std_13,
zcr, rms, spec_centroid, spec_bandwidth, spec_rolloff, spec_contrast,
pitch_mean, pitch_std
```

---

## Dependencies

- `librosa`  
- `numpy`  
- `pandas`  

---

## License

MIT License

---

## Author

Dhyan Sudheer
markus-autotest-helpers-python 0.1.0
Helper functions and classes for executing Python unit tests
Requires Python: >=3.9

# Python Helper

Helper functions and classes for executing python unit tests.

## Installation

```shell
pip install markus-autotest-helpers-python
```

## General helpers

### bound_timeout(`seconds`)
Return a decorator that will time out the test case after `seconds` seconds. 

A MarkUs-compatible function wrapper based on `timeout_decorator` that will return the original error message if one is raised instead of a Timeout. A TimeoutError will be raised if the provided time (in seconds) is exceeded.

#### Usage

```python
@bound_timeout(10)	# This will timeout if my_function takes longer than 10 seconds to run.
def my_function() -> None:
	...
```
markus-autotest-helpers-notebook 0.1.0
Helper functions for importing and testing Jupyter notebooks.
Requires Python: >=3.9

# Notebook Helper

Helper functions for importing and testing jupyter notebooks.

See [function/class docstrings](./src/markus_autotest_helpers_notebook/__init__.py) for more information.

## Installation:

```shell
pip install markus-autotest-helpers-notebook'
```
markus-autotest-helpers-c 0.1.0
Helper functions and classes for executing python unit tests that require execution of c code
Requires Python: >=3.9

# C Helper

Helper functions and classes for executing python unit tests that require execution of c code.

See [function/class docstrings](./src/markus-autotest-helpers-c/__init__.py) for more information.

## Installation:

```shell
pip install markus-autotest-helpers-c
```
repo-parser 0.0.3
A library for extracting metadata out of a source repository.
Requires Python: >=3.11

# repo-parser

This is a set of python scripts and tools for extracting metadata and structure
out of a monorepo, for the purposes of generating a service registry, unified documentation, or other types of data out of the contents. It also contains some
tooling designed around a new concept called "Implementation Decision Records" (idrs), designed to aid both implementation (especially where assisted by LLMs) and later code archaeology efforts.

It should be considered an experiment, rather than production software. It is inspired by my experiences in the software industry and being frustrated with current solutions being some combination of:

- Time consuming to configure and maintain
- Requiring the specification of redundant metadata (which is bound to get out of date)

Current assumptions:

- The files you want to process fit into memory
- You don't care about history (repo-parser gives a snapshot in time)

You can see a demo of a documentation site generated from this repo at:

https://repo-parser-demo.netlify.app/

> [!NOTE]
> repo-parser is partly created with LLMs (specifically, Claude Code and ChatGPT),
> with heavy human curation.

## Usage

### Creating IDRs (Implementation Decision Records)

repo-parser includes a CLI tool (`rp`) for creating Implementation Decision Records (IDRs). IDRs are lightweight documents that capture both the intent and implementation details of code changes, designed to be committed alongside your code.

They are intended to be useful for both humans and computational agents (LLMs).

**Why IDRs?** Traditional design docs are too heavyweight for implementation. ADRs are great for decisions but lack implementation detail. IDRs bridge the gap—detailed enough to guide implementation, ephemeral enough to not become stale documentation.

Create a new IDR:

```bash
rp idr new "Your Feature Title"
```

This will create a new markdown file in the `idrs/` directory with:

- A UTC timestamp prefix (e.g., `202512301600`)
- A slugified version of your title
- Pre-filled template with your git author name

Example:

```bash
rp idr new "Add last modified metadata"
# Creates: idrs/202512301600-add-last-modified-metadata.md
```

The IDR template includes sections for:

- Problem Statement
- Context
- Goals and Non-Goals
- Proposed Solution
- Detailed Design
- Implementation notes (ephemeral)

This feature was itself implemented using an IDR—see [idrs/202512301631-idrs.md](idrs/202512301631-idrs.md) for more about the IDR format and philosophy.

### Using repo-parser as a Library

For documentation generation and metadata extraction, see the example in `example/example_parser.py`.

An early version of repo-parser is available on pypi as https://pypi.org/project/repo-parser. Use at your own risk!

## Local development

You can experiment with the local demo by running `make example`.
It should live-reload as you make changes in the `example/repo` directory.

For other tasks, look at the (very simple) `Makefile` in the root directory.
sourcerat 0.1.3
Collect and bundle source code for LLM input
Requires Python: >=3.11

# sourcerat

**sourcerat** collects, filters, and orders source code from a project so it can be used as high-quality context for LLMs.  
The goal is not archiving, but **signal over noise**.

## Project Vision

LLMs perform poorly on raw project dumps.  
Too many files, wrong ordering, irrelevant clutter.

`sourcerat` addresses this structurally:

- identify relevant files
- prioritize entry points
- expose project structure
- keep output deterministic and reproducible
- no magic, everything explainable

Built for developers who want **explicit control** over what a model sees.

## Installation

```sh
pip install sourcerat
````

or locally in a project:

```sh
pip install -e .
```

## Usage

Basic form:

```sh
sourcerat [PATH]
```

By default, the current directory is scanned.

Example:

```sh
sourcerat .
```

Output:

* PROJECT TREE
* followed by the contents of selected files
* ordered by heuristic relevance

## Common Workflows

### Dry Run

Show which files would be included:

```sh
sourcerat . --dry-run
```

### Write Output to File

```sh
sourcerat . -o context.txt
```

### Markdown for ChatGPT / GitHub

```sh
sourcerat . --format markdown -o context.md
```

### Restrict File Types

```sh
sourcerat . --file-suffixes py,rs
```

### Explicitly Include Directories

```sh
sourcerat . --include src
```

### Exclude Directories

```sh
sourcerat . --exclude tests,examples
```

### Size and Count Limits

```sh
sourcerat . --max-files 20 --max-lines 400
```

## Smart Sorting

By default, `sourcerat` tries to surface important files first.

Heuristics include:

* common entry points (`main.py`, `__main__.py`, `cli.py`)
* shallow directory depth
* detection of `main()` functions
* CLI indicators such as `argparse`, `click`, `typer`
* de-prioritization of `tests`, `examples`, `demo`

Disable:

```sh
sourcerat . --no-smart-sort
```

## Gitignore Support

```sh
sourcerat . --respect-gitignore
```

* reads `.gitignore` from project root
* simple, transparent pattern matching
* intentionally not a full Git implementation

## Output Formats

### Plain (default)

```
PROJECT TREE
├── src
│   └── app.py

FILE: src/app.py
<content>
```

### Markdown

````md
## src/app.py
```python
<content>
````

```

Designed for direct LLM consumption.

## Design Principles

- no dependencies
- no hidden defaults
- everything is text
- heuristic correctness over completeness
- errors are visible, not hidden

## Non-Goals

- not a documentation generator
- not a full parser
- no AST or semantic analysis
- not a project management tool

## Intended Audience

- developers using LLMs deliberately
- code-centric prompt engineering
- analyzing unfamiliar codebases
- fast project onboarding

## Status

Early version, intentionally small.  
Heuristics are extensible but conservative by design.

Pull requests welcome if they respect the vision.
```
caddy-api-client 0.2.5
A Python client for the Caddy API
Requires Python: >=3.7

# Caddy API Client

A Python client for managing Caddy server configurations through its API.

## Installation

### Production Installation (Recommended)

For production workloads, it's recommended to install the package from PyPI:

```bash
pip install caddy-api-client
```

### Development Installation

For development or if you need to modify the client:

1. Clone the repository:
```bash
git clone https://github.com/migetapp/caddy-api-client.git
cd caddy-api-client
```

2. Install the package in development mode:
```bash
pip install -e .
```

## Usage

```python
from caddy_api_client import CaddyAPIClient

# Initialize the client
client = CaddyAPIClient("http://localhost:2019")  # Default Caddy admin endpoint

# Add a domain with automatic TLS (Let's Encrypt/ZeroSSL) and www redirect
client.add_domain_with_auto_tls(
    domain="example.org",
    target="nginx",
    target_port=80,
    redirect_mode="domain_to_www",  # Redirects example.org to www.example.org
    enable_security_headers=True,    # Adds security headers
    enable_hsts=True                 # Enables HSTS
)

# Add a domain with www to non-www redirect
client.add_domain_with_auto_tls(
    domain="www.example.net",
    target="192.168.10.101",
    target_port=80,
    redirect_mode="www_to_domain"  # Redirects www.example.net to example.net
)

# Add a domain with custom TLS certificates using PEM data
with open('cert.pem', 'r') as f:
    certificate = f.read()
with open('key.pem', 'r') as f:
    private_key = f.read()

client.add_domain_with_tls(
    domain="example.net",
    target="192.168.10.101",
    target_port=80,
    certificate=certificate,
    private_key=private_key
)

# Get domain configuration
config = client.get_domain_config("example.com")
print(config)

# Update domain configuration
client.update_domain(
    domain="example.com",
    target="172.16.0.2",
    target_port=8080,
    redirect_mode="domain_to_www"  # Add or update redirect configuration
)

# Delete domain
client.delete_domain("example.com")  # Removes domain and its redirect configuration

## Features

- Add domains with TLS certificates using PEM data
- Add domains with automatic TLS (Let's Encrypt/ZeroSSL)
- Configure domain redirects:
  - www to non-www (`www_to_domain`)
  - non-www to www (`domain_to_www`)
- Security features:
  - Security headers (Server, X-Frame-Options, etc.)
  - HTTP Strict Transport Security (HSTS)
  - HTTP to HTTPS redirect
  - Path-based security rules
- Delete domain configurations (preserves other domain configurations)
- Get domain configurations
- Update domain configurations
- Support for HTTP/2 and HTTP/3

## Error Handling

The client includes comprehensive error handling for API requests. All methods will raise exceptions with descriptive messages if something goes wrong during the API calls.

## License

This project is licensed under the Apache License, Version 2.0 - see the [LICENSE](LICENSE) file for details.

Copyright 2025 Krzysztof Taraszka and The Miget Authors.
pegasuspy 1.11.0rc2
Pegasus is a Python package for analyzing sc/snRNA-seq data of millions of cells
Requires Python: ~=3.10
Keywords: single cell/nucleus genomics analysis

====================================
Pegasus for Single Cell Analysis
====================================

|PyPI| |PyPIDownload| |Conda| |Python| |License| |Docs| |Build|

.. |PyPI| image:: https://img.shields.io/pypi/v/pegasuspy.svg
   :target: https://pypi.org/project/pegasuspy
.. |PyPIDownload| image:: https://pepy.tech/badge/pegasuspy
   :target: https://pepy.tech/project/pegasuspy
.. |Conda| image:: https://img.shields.io/conda/v/bioconda/pegasuspy
   :target: https://anaconda.org/bioconda/pegasuspy
.. |Python| image:: https://img.shields.io/pypi/pyversions/pegasuspy
   :target: https://pypi.org/project/pegasuspy
.. |License| image:: https://img.shields.io/github/license/lilab-bcb/pegasus
   :target: https://github.com/lilab-bcb/pegasus/blob/master/LICENSE
.. |Docs| image:: https://readthedocs.org/projects/pegasus/badge/?version=latest
   :target: https://pegasus.readthedocs.io/
.. |Build| image:: https://github.com/lilab-bcb/pegasus/workflows/Pegasus%20CI/badge.svg
   :target: https://github.com/lilab-bcb/pegasus/actions?query=workflow%3A%22Pegasus+CI%22


Pegasus is a tool for analyzing transcriptomes of millions of single cells. It is a command line tool, a python package and a base for Cloud-based analysis workflows.

`Read documentation <http://pegasus.readthedocs.io>`__