semvec/pypi-packages huggingface dataset:
agentpulse-sdk 0.2.0
Zero-config agent observability SDK — auto-captures LLM calls, costs, and traces
Requires Python: >=3.9
Keywords: agents, anthropic, llm, observability, openai, tracing

# AgentPulse SDK

Zero-config observability for AI agents. Two lines of code → full LLM call tracking with costs, latency, and traces.

## Quick Start

```bash
pip install agentpulse
```

```python
import agentpulse
agentpulse.init()  # That's it — all LLM calls are now tracked

import openai
client = openai.OpenAI()
resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)
# → Dashboard shows: model, tokens, cost, latency — automatically
```

## What Gets Captured

With just `agentpulse.init()`, the SDK automatically captures:

- **LLM calls** — model, tokens, latency, cost (OpenAI, Anthropic, LiteLLM)
- **Errors** — failed API calls with error details
- **Streaming** — full metrics even for streamed responses
- **Cost estimates** — built-in pricing for 30+ models

## Structured Tracing

For richer observability, add sessions, agents, and tasks:

```python
import agentpulse
ap = agentpulse.init()

# Group related calls into sessions
with ap.session("daily-email-check") as s:
    result = process_emails()
    s.log("Processed 5 emails")
    s.set_result("success")

# Decorate agents and tasks
@agentpulse.agent(name="email-processor")
class EmailAgent:
    @agentpulse.task(name="classify")
    def classify(self, email):
        return call_llm(email)

# Monitor cron jobs
with ap.cron("nightly-cleanup") as c:
    do_cleanup()
    # Auto-captures: start, end, duration, success/failure
```

## Manual Events

```python
ap.event("memory_snapshot", {"file": "MEMORY.md", "size_kb": 142})
ap.metric("queue_depth", 23)
ap.alert("Cost spike", severity="warning", details="$5.20 in last hour")
```

## Configuration

All via `init()` kwargs or environment variables:

```python
agentpulse.init(
    api_key="ap_...",              # or AGENTPULSE_API_KEY
    agent_name="my-agent",         # or AGENTPULSE_AGENT (default: hostname)
    endpoint="https://...",        # or AGENTPULSE_ENDPOINT
    enabled=True,                  # or AGENTPULSE_ENABLED (kill switch)
    capture_messages=False,        # or AGENTPULSE_CAPTURE_MESSAGES (privacy)
    auto_patch=True,               # or AGENTPULSE_AUTO_PATCH
    debug=False,                   # or AGENTPULSE_DEBUG
    flush_interval=5.0,            # seconds between flushes
    max_queue_size=10_000,         # max buffered events
)
```

## CLI

```bash
agentpulse status   # Check config and connectivity
agentpulse test     # Send a test event
agentpulse costs    # Print the built-in cost table
```

## Design Principles

- **Zero dependencies** — stdlib only (`urllib`, `json`, `threading`, `contextvars`)
- **Never blocks** — all reporting is fire-and-forget via background thread
- **<1ms overhead** — just a timestamp + queue append per LLM call
- **Privacy by default** — prompt/response content not captured unless opted in
- **Unpatchable** — `shutdown()` restores all original library methods

## License

MIT
faceswitch 0.2.1
Simple multi-model face detection library
Requires Python: >=3.10
Keywords: face-detection, computer-vision, hog, dlib

# FaceSwitch

FaceSwitch is a Python library that provides a common interface for multiple face detection backends.

## Features

- Clean detector interface
- Optional backend dependencies via extras
- Pluggable architecture
- Automatic model download for supported backends
- Typed API (`FaceBox`)

## Requirements

- Python 3.10+

## Installation

```bash
pip install faceswitch
```

Install a specific backend via extras:

```bash
pip install "faceswitch[<backend>]"
```

Examples:

```bash
pip install "faceswitch[hog]"
pip install "faceswitch[yolo]"
```

Install demo dependencies (`opencv-python`):

```bash
pip install "faceswitch[examples]"
```

Install all optional dependencies:

```bash
pip install "faceswitch[all]"
```

## Backend Model

- Each detector backend is optional and installed through extras.
- New backends can be added without changing the core detection interface.
- Current backend extras include `hog` and `yolo`.

## Minimal Usage (Backend-Agnostic)

```python
import cv2
from faceswitch.detectors.hog import HogDetector

image = cv2.imread("path/to/image.png")
if image is None:
    raise ValueError("Could not read image")

detector = HogDetector()
faces = detector.detect(image)

print(f"Detected: {len(faces)}")
```

To switch backend later, replace `HogDetector` with another detector class from `faceswitch` (for example, `YoloDetector`) and install its matching extra.

## Detector Interface

```python
faces = detector.detect(image)
```

All detectors return a list of `FaceBox` values:

```python
FaceBox(
    x1=int,  # left
    y1=int,  # top
    x2=int,  # right
    y2=int,  # bottom
    confidence=float | None,
)
```

Some detectors may include backend-specific behavior (for example, model download/caching) documented in their module or config.

## Run Demos

```bash
python examples/demo_hog.py path/to/image.png
python examples/demo_yolo.py path/to/image.png
```

## Adding New Backends

FaceSwitch is designed to grow with more detector implementations. For contribution workflow and detector contract requirements, see `CONTRIBUTING.md` and `ARCHITECTURE.md`.
rcsb.utils.chem 0.86
RCSB Python Chemical Utility Classes
Requires Python: >=3.9

# py-rcsb_utils_chem

[![Build Status](https://dev.azure.com/rcsb/RCSB%20PDB%20Python%20Projects/_apis/build/status/rcsb.py-rcsb_utils_chem?branchName=master)](https://dev.azure.com/rcsb/RCSB%20PDB%20Python%20Projects/_build/latest?definitionId=20&branchName=master)

RCSB Python tools for accessing and annotating PDB chemical components definitions.

## Introduction

Utilities for managing, comparing and searching PDB chemical component definitions.
This module has internal dependencies on: OpenEye OECHEM toolkits, RDKIT,
OpenBabel/Pybel, and CACTVS.  These dependencies require separate installation
that is described with each chemical package.

### Installation

Download the library source software from the project repository:

```bash

git clone --recurse-submodules https://github.com/rcsb/py-rcsb_utils_chem.git

```

Optionally, run test suite (Python versions 3.9) using
[tox](http://tox.readthedocs.io/en/latest/example/platform.html):

```bash
tox
```

Installation is via the program [pip](https://pypi.python.org/pypi/pip).  To run tests
from the source tree, the package must be installed in editable mode (i.e. -e):

```bash
pip install -e .
```
lobster-proteomics 1.0.10
Proteomics agent for Lobster AI (DDA/DIA mass spectrometry, affinity platforms)
Requires Python: <3.14,>=3.12
Keywords: bioinformatics, proteomics, mass-spectrometry, DDA, DIA, Olink, SomaScan, lobster-ai

# lobster-proteomics

Unified proteomics analysis for mass spectrometry (DDA/DIA) and affinity platforms (Olink, SomaScan).

## Installation

```bash
pip install lobster-proteomics
```

## Agents

| Agent | Description |
|-------|-------------|
| `proteomics_expert` | Full proteomics workflow orchestration with auto-detection of platform type and appropriate preprocessing. |

## Services

| Service | Purpose |
|---------|---------|
| ProteomicsAnalysisService | Core analysis workflows for protein quantification |
| ProteomicsDifferentialService | Differential protein expression between conditions |
| ProteomicsSurvivalService | Survival analysis with protein biomarkers |
| ProteomicsNetworkService | Protein-protein interaction network analysis |
| ProteomicsQualityService | Quality control and missing value assessment |
| ProteomicsPreprocessingService | MNAR/MAR-aware imputation and normalization |
| ProteomicsVisualizationService | Volcano plots, heatmaps, and network graphs |
| MaxQuantParser | Parse MaxQuant proteinGroups.txt output |
| DIANNParser | Parse DIA-NN report.tsv output |
| SpectronaultParser | Parse Spectronaut report output |
| OlinkParser | Parse Olink NPX export files |

## Features

- Auto-detection of platform type from data characteristics
- Missing value handling optimized for MNAR (mass spec) vs MAR (affinity) patterns
- Platform-appropriate quality control with batch effect detection
- Median and quantile normalization with log2 transformation
- Multiple imputation strategies (MinDet, KNN, zero, median)
- Differential protein analysis with multiple testing correction
- Volcano plots and MA plots for results visualization
- Protein-protein interaction network construction and visualization
- Survival analysis integration for clinical proteomics studies
- Support for multi-plex affinity platforms (Olink, SomaScan, Luminex)

## Platform Support

| Platform | Missing Values | Normalization | Notes |
|----------|---------------|---------------|-------|
| Mass Spectrometry (DDA/DIA) | 30-70% (MNAR) | Median + log2 | Peptide mapping support |
| Affinity (Olink) | <30% (MAR) | Quantile | Plate effect correction |
| Affinity (SomaScan) | <30% (MAR) | Quantile | Antibody validation |

## Requirements

- Python 3.12+
- lobster-ai >= 1.0.0

## Tier Requirement

This is a **premium** agent. Access is controlled at runtime via Lobster AI's tier system.

## Documentation

Full documentation: [docs.omics-os.com/docs/agents/proteomics](https://docs.omics-os.com/docs/agents/proteomics)

## License

MIT
lobster-genomics 1.0.10
Genomics agent for Lobster AI (VCF, PLINK, GWAS, variant annotation)
Requires Python: <3.14,>=3.12
Keywords: bioinformatics, genomics, GWAS, VCF, PLINK, variant-annotation, lobster-ai

# lobster-genomics

Genomics analysis for VCF and PLINK data with GWAS, QC, and variant annotation capabilities.

## Installation

```bash
pip install lobster-genomics
```

## Agents

| Agent | Description |
|-------|-------------|
| `genomics_expert` | Full genomics workflow orchestration including data loading, quality control, GWAS analysis, and variant annotation. |

## Services

| Service | Purpose |
|---------|---------|
| GWASService | Genome-wide association study analysis with linear/logistic regression |
| VariantAnnotationService | Variant functional annotation via Ensembl VEP integration |
| GenomicsQualityService | Comprehensive QC including call rate, MAF, HWE, and heterozygosity |

## Features

- Load VCF files (whole genome sequencing) and PLINK files (SNP arrays)
- Comprehensive quality control with configurable thresholds
- Call rate filtering at both sample and variant level
- Minor allele frequency (MAF) filtering for rare variant removal
- Hardy-Weinberg equilibrium testing for genotyping errors
- Heterozygosity outlier detection for sample quality assessment
- Linear and logistic regression GWAS with covariate support
- Lambda GC calculation for population stratification assessment
- Principal component analysis (PCA) for ancestry detection
- Variant functional annotation via Ensembl VEP API
- Manhattan plots and QQ plots for GWAS visualization
- PCA scatter plots colored by phenotype or ancestry

## Requirements

- Python 3.12+
- lobster-ai >= 1.0.0
- cyvcf2 (VCF parsing)
- bed-reader (PLINK file support)
- sgkit (GWAS and PCA analysis)

## Tier Requirement

This is a **premium** agent. Access is controlled at runtime via Lobster AI's tier system.

## Documentation

Full documentation: [docs.omics-os.com/docs/agents/genomics](https://docs.omics-os.com/docs/agents/genomics)

## License

MIT
lobster-research 1.0.10
Research agents for Lobster AI - literature discovery and data management
Requires Python: <3.14,>=3.12
Keywords: bioinformatics, literature-search, pubmed, geo, data-management, dataset-discovery, omics

# lobster-research

Literature discovery and data acquisition agents for scientific research workflows.

## Installation

```bash
pip install lobster-research
```

## Agents

| Agent | Description |
|-------|-------------|
| `research_agent` | Literature discovery specialist. PubMed/bioRxiv search, GEO/SRA dataset discovery, metadata extraction, publication queue management. |
| `data_expert_agent` | Data operations specialist. Queue-based downloads, modality management, local file loading, workspace orchestration. |

## Services

| Service | Purpose |
|---------|---------|
| ModalityDetectionService | Auto-detect data modality type from file characteristics |

## Features

### Research Agent (Online Operations)
- PubMed literature search with filters and related paper discovery
- bioRxiv and medRxiv preprint search with full-text access
- GEO dataset discovery with organism and platform filtering
- SRA run metadata extraction and download URL generation
- PRIDE proteomics repository integration
- Full-text content extraction from PMC articles
- Methods section parsing for computational parameter discovery
- Publication queue for batch processing of research papers
- Automatic extraction of associated dataset identifiers

### Data Expert Agent (Offline Operations)
- Execute downloads from pre-validated queue entries
- Zero online access boundary for security and reproducibility
- Multi-format file loading (CSV, TSV, H5AD, Excel)
- Modality listing, inspection, and validation
- Download strategy selection (AUTO, H5_FIRST, MATRIX_FIRST)
- Sample concatenation with union or intersection logic
- Failed download retry with exponential backoff
- Custom Python code execution for edge cases

### Platform Support
- 10x Genomics MTX format (matrix, barcodes, features)
- H5AD pre-processed AnnData files
- Kallisto and Salmon bulk RNA-seq quantification
- CSV and TSV generic delimited matrices
- MaxQuant, Olink, and generic proteomics formats

## Architecture

The research and data_expert agents implement a clean boundary pattern:

```
research_agent (ONLINE)              data_expert (OFFLINE)
-- Search literature                 -- Execute downloads
-- Discover datasets                 -- Load local files
-- Extract metadata/URLs             -- Manage modalities
-- Validate metadata                 -- Retry failed downloads
-- Create queue entries              -- Concatenate samples
         |                                    |
         ----------- Queue Entry -------------
                   (PENDING -> IN_PROGRESS -> COMPLETED)
```

## Requirements

- Python 3.12+
- lobster-ai >= 1.0.0

## Documentation

Full documentation: [docs.omics-os.com/docs/agents/research](https://docs.omics-os.com/docs/agents/research)

## License

MIT
lobster-visualization 1.0.10
Visualization agent for Lobster AI - publication-quality plots and interactive visualizations
Requires Python: <3.14,>=3.12
Keywords: bioinformatics, visualization, plotting, single-cell, omics

# lobster-visualization

Publication-quality plots and interactive visualizations for bioinformatics data analysis.

## Installation

```bash
pip install lobster-visualization
```

## Agents

| Agent | Description |
|-------|-------------|
| `visualization_expert` | General-purpose visualization agent for creating publication-ready figures across all omics data types. |

## Services

| Service | Purpose |
|---------|---------|
| VisualizationService | Core plotting engine with Plotly-based interactive visualizations |

## Features

- UMAP plots with automatic point size scaling based on cell count
- PCA plots with variance explained annotations
- t-SNE visualizations for dimensionality reduction
- Violin plots for gene expression distribution by cluster
- Feature plots showing expression intensity on embeddings
- Dot plots for marker gene comparison across clusters
- Heatmaps with optional row and column standardization
- Elbow plots for PCA variance analysis and component selection
- Cluster composition stacked bar charts for sample contribution
- QC plots with scientific validation (skips inappropriate modalities)
- Interactive Plotly figures with zoom, pan, and hover tooltips
- Static PNG export for publication and presentation use
- Consistent color palettes across related visualizations
- Automatic figure sizing based on data dimensions

## Requirements

- Python 3.12+
- lobster-ai >= 1.0.0
- plotly

## Documentation

Full documentation: [docs.omics-os.com/docs/agents/visualization](https://docs.omics-os.com/docs/agents/visualization)

## License

AGPL-3.0-or-later
lobster-transcriptomics 1.0.10
Transcriptomics agents for Lobster AI - single-cell and bulk RNA-seq analysis
Requires Python: <3.14,>=3.12
Keywords: bioinformatics, single-cell, RNA-seq, transcriptomics, scRNA-seq, bulk-rnaseq, differential-expression, cell-type-annotation

# lobster-transcriptomics

Single-cell and bulk RNA-seq analysis agents for the Lobster AI platform.

## Installation

```bash
pip install lobster-transcriptomics
```

## Agents

| Agent | Description |
|-------|-------------|
| `transcriptomics_expert` | Parent orchestrator for single-cell and bulk RNA-seq workflows. Handles QC, clustering, and coordinates sub-agents. |
| `annotation_expert` | Cell type annotation specialist. Automated and manual annotation, debris detection, annotation templates. |
| `de_analysis_expert` | Differential expression specialist. Pseudobulk aggregation, pyDESeq2, pathway enrichment. |

## Services

| Service | Purpose |
|---------|---------|
| EnhancedSingleCellService | Single-cell clustering and analysis workflows |
| PseudobulkService | Aggregate single-cell data to pseudobulk for DE analysis |
| DifferentialFormulaService | Formula-based differential expression with pyDESeq2 |
| QualityService | Comprehensive QC metrics calculation and filtering |
| PreprocessingService | Normalization, log transformation, and preprocessing |
| ManualAnnotationService | Manual cluster annotation with template support |
| AnnotationTemplates | Tissue-specific marker gene templates (PBMC, brain, lung) |
| BulkVisualizationService | Publication-quality plots for bulk RNA-seq results |

## Features

- Auto-detection of single-cell vs bulk RNA-seq data types
- Comprehensive QC metrics including gene counts, mitochondrial %, and ribosomal %
- Flexible filtering with data-type-appropriate default thresholds
- Leiden clustering with multi-resolution support and quality metrics
- UMAP visualization with automatic point size scaling
- Deviance-based highly variable gene selection
- Batch correction for multi-sample experimental designs
- Sub-clustering for heterogeneous cell populations
- Tissue-specific annotation templates for rapid cell type identification
- Pseudobulk aggregation from single-cell to bulk format
- Formula-based DE analysis supporting complex experimental designs
- GO and KEGG pathway enrichment for biological interpretation

## Requirements

- Python 3.12+
- lobster-ai >= 1.0.0

## Documentation

Full documentation: [docs.omics-os.com/docs/agents/transcriptomics](https://docs.omics-os.com/docs/agents/transcriptomics)

## License

MIT
mrkwatkins-oakemu 0.0.31
Python wrappers for the OakEmu project.
Requires Python: <3.14,>=3.11

# OakEmu-Python

[![Build Status](https://github.com/MrKWatkins/OakEmu-Python/actions/workflows/build.yml/badge.svg)](https://github.com/MrKWatkins/OakEmu-Python/actions/workflows/build.yml)
[![PyPI - Version](https://img.shields.io/pypi/v/mrkwatkins-oakemu)](https://pypi.org/project/mrkwatkins-oakemu/)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/mrkwatkins-oakemu)](https://pypi.org/project/mrkwatkins-oakemu/)

> Python wrappers for the [OakEmu](https://github.com/MrKWatkins/OakEmu) project.
fastapi-cli-slim 0.0.23
Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀
Requires Python: >=3.10

# FastAPI CLI

<a href="https://github.com/fastapi/fastapi-cli/actions/workflows/test.yml" target="_blank">
    <img src="https://github.com/fastapi/fastapi-cli/actions/workflows/test.yml/badge.svg" alt="Test">
</a>
<a href="https://github.com/fastapi/fastapi-cli/actions/workflows/publish.yml" target="_blank">
    <img src="https://github.com/fastapi/fastapi-cli/actions/workflows/publish.yml/badge.svg" alt="Publish">
</a>
<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/fastapi-cli" target="_blank">
    <img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/fastapi-cli.svg" alt="Coverage">
<a href="https://pypi.org/project/fastapi-cli" target="_blank">
    <img src="https://img.shields.io/pypi/v/fastapi-cli?color=%2334D058&label=pypi%20package" alt="Package version">
</a>

---

**Source Code**: <a href="https://github.com/fastapi/fastapi-cli" target="_blank">https://github.com/fastapi/fastapi-cli</a>

---

Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀

## `fastapi-cli-slim`

⚠️ Do not install this package. ⚠️

This package, `fastapi-cli-slim`, does nothing other than depend on `fastapi-cli`.

You **should not** install this package.

Install instead:

```bash
pip install "fastapi[standard]"
```

or:

```bash
pip install fastapi-cli
```

This package is deprecated and will stop receiving any updates and published versions.

## License

This project is licensed under the terms of the MIT license.
pynado 0.1.3
A friendly, Pythonic wrapper for the Nado Protocol SDK
Requires Python: >=3.9

# Pynado

A friendly, Pythonic wrapper for the [Nado Protocol SDK](https://github.com/nadohq/nado-python-sdk). Pynado simplifies the interaction with the Nado Protocol by abstracting low-level details and handling unit conversions automatically.

## Installation

```bash
pip install pynado
```

## Usage

### 1. Setup

Create a `.env` file in your project root to store your private key securely:

```env
NADO_PRIVATE_KEY='your_private_key_here'
```

### 2. Basic Example

Initialize the client and check your account details:

```python
from pynado import Nado

# Initialize the client (defaults to TESTNET and loads key from .env)
client = Nado()

# Access properties directly
print(f"Wallet Address: {client.address}")
print(f"USDT Balance:   {client.balance:,.2f}")
```

### 3. Trading (Market Orders)

Pynado handles symbol resolution (Spot vs. Perp) and unit scaling (`to_x18`) automatically.

```python
# Market Buy 0.01 BTC (Spot)
client.buy("BTC", 0.01)

# Market Sell 0.5 ETH (Perp)
client.sell("ETH-PERP", 0.5)
```

### 4. Checking Positions

You can easily check specific positions or get an overview of your entire account.

```python
# Get a specific position
pos = client.get_position("BTC-PERP")
print(f"Amount: {pos['amount']}, Entry Price: {pos['average_entry_price']}")

# Get all active positions
all_pos = client.get_all_positions()
for p in all_pos:
    print(f"{p['symbol']}: {p['amount']}")
```

## Features

*   **Simple Interface:** One class (`Nado`) to rule them all.
*   **Automatic Scaling:** Handles 18-decimal scaling for you (returns `float` for balances, accepts `float` for orders).
*   **Symbol Resolution:** Supports both Spot ("BTC") and Perp ("BTC-PERP") symbols.
*   **Position Management:** Friendly methods to retrieve current holdings and average entry prices.
*   **Environment Friendly:** Native support for `.env` files.