semvec/pypi-packages huggingface dataset:
jotbot 0.1.1
Push-to-talk voice dictation for macOS
Requires Python: >=3.10
Keywords: deepgram, dictation, macos, transcription, voice, whisper

# Jotbot

Push-to-talk voice dictation for macOS. Hold a hotkey combo to record, release to transcribe and paste at your cursor.

Built for use with Claude Code and other CLI tools.

## Features

- **Real-time streaming** with Deepgram Nova-2 (recommended)
- **Batch transcription** with OpenAI Whisper (fallback)
- **Code-aware formatting** with Claude Haiku (optional)
- **Clipboard preservation** - your clipboard is restored after pasting

## Hotkeys

| Combo | Action |
|-------|--------|
| `Ctrl+Option` | Record and transcribe (raw) |
| `Cmd+Ctrl+Option` | Record, transcribe, and format with Haiku (hold Cmd first) |

## Installation

```bash
pip install jotbot
```

Or with [pipx](https://pipx.pypa.io/) (recommended):

```bash
pipx install jotbot
```

## Setup

Run the interactive setup to configure your API keys:

```bash
jotbot --setup
```

This will prompt you to choose a transcription backend and enter your API keys:

- **Deepgram** (recommended): Real-time streaming, ~$0.0077/min - [Get key](https://console.deepgram.com)
- **OpenAI Whisper**: Batch processing, ~$0.006/min - [Get key](https://platform.openai.com)
- **Anthropic** (optional): For Haiku formatting mode - [Get key](https://console.anthropic.com)

Config is saved to `~/.config/jotbot/.env`.

### macOS Permissions

Your terminal app needs **Input Monitoring** permission:

System Settings → Privacy & Security → Input Monitoring → Enable your terminal (Warp, iTerm2, Terminal.app, etc.)

## Usage

```bash
jotbot
```

Then in any app:
1. Hold `Ctrl+Option` (or `Cmd+Ctrl+Option` for formatted output)
2. Speak
3. Release to transcribe and paste

## How it works

- **Audio**: Records via `sounddevice` at 16kHz mono
- **Transcription**:
  - Deepgram Nova-2 (streaming, low latency) - recommended
  - OpenAI Whisper (batch, higher latency) - fallback
- **Formatting** (optional): Claude Haiku cleans up text, adds backticks for code identifiers
- **Output**: Copies to clipboard, simulates Cmd+V, restores original clipboard

## Backends

### Deepgram (Recommended)

- Real-time streaming transcription
- Persistent WebSocket connection (instant start)
- ~$0.0077/min

### Whisper

- Batch transcription after recording ends
- Higher latency but very accurate
- ~$0.006/min

## Development

```bash
git clone https://github.com/isaacgor216/jotbot.git
cd jotbot
python -m venv .venv
source .venv/bin/activate
pip install -e .
```

## License

MIT
calcos 3.6.2
Calibration software for COS (Cosmic Origins Spectrograph)
Requires Python: >=3.10

# CALCOS

Calibration software for HST/COS.

[![CalCOS Pytest](https://github.com/spacetelescope/calcos/actions/workflows/python_testing.yml/badge.svg)](https://github.com/spacetelescope/calcos/actions/workflows/python_testing.yml)
[![test CalCOS](https://github.com/spacetelescope/RegressionTests/actions/workflows/calcos.yml/badge.svg)](https://github.com/spacetelescope/RegressionTests/actions/workflows/calcos.yml)

[Documentation](https://hst-docs.stsci.edu/cosdhb/chapter-3-cos-calibration)
asdf-coordinates-schemas 0.5.1
ASDF schemas for coordinates
Requires Python: >=3.10

# asdf-coordinates-schemas
![CI](https://github.com/asdf-format/asdf-coordinates-schemas/workflows/CI/badge.svg)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

This package provides ASDF schemas for validating coordinates tags.  Users should not
need to install this directly; instead, install an implementation package such
as asdf-astropy, which includes asdf-coordinates-schemas as a dependency.
llama-index-tools-seltz 0.1.0
llama-index tools seltz integration
Requires Python: <4.0,>=3.9

# Seltz Web Knowledge Tool

[Seltz](https://www.seltz.ai/) provides fast, up-to-date web data with context-engineered web content and sources for real-time AI reasoning. Web content is processed and shaped to maximize usefulness for LLMs, AI agents, and RAG pipelines.

To begin, you need to obtain an API key from [Seltz](https://www.seltz.ai/).

## Installation

```bash
pip install llama-index-tools-seltz
```

## Usage

```python
from llama_index.tools.seltz import SeltzToolSpec
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI

seltz_tool = SeltzToolSpec(api_key="your-seltz-api-key")

agent = FunctionAgent(
    tools=seltz_tool.to_tool_list(),
    llm=OpenAI(model="gpt-4o"),
)

await agent.run("What are the latest developments in AI reasoning?")
```

## Available Functions

`search`: Search the web using Seltz and return relevant documents with sources. Returns a list of Document objects containing web content and source URLs.

### Parameters

- `query` (str): The search query text.
- `max_documents` (int, optional): Maximum number of documents to return (default: 10).

### Example

```python
from llama_index.tools.seltz import SeltzToolSpec

seltz_tool = SeltzToolSpec(api_key="your-seltz-api-key")

documents = seltz_tool.search("web knowledge for AI agents", max_documents=5)

for doc in documents:
    print(f"URL: {doc.metadata['url']}")
    print(f"Content: {doc.text[:200]}...")
```

This tool is designed to be used as a way to load data as a Tool in an Agent.
datasette-pins 0.1a7
Pin databases, tables, and other items to the Datasette homepage
Requires Python: >=3.10

# datasette-pins

[![PyPI](https://img.shields.io/pypi/v/datasette-pins.svg)](https://pypi.org/project/datasette-pins/)
[![Changelog](https://img.shields.io/github/v/release/datasette/datasette-pins?include_prereleases&label=changelog)](https://github.com/datasette/datasette-pins/releases)
[![Tests](https://github.com/datasette/datasette-pins/actions/workflows/test.yml/badge.svg)](https://github.com/datasette/datasette-pins/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/datasette/datasette-pins/blob/main/LICENSE)

Pin databases, tables, queries, and more to the Datasette homepage!

<img src="https://datasette-cloud-assets.s3.amazonaws.com/blog/2024/datasette-pins/hero.png"/>

## Installation

`datasette-pins` requires a recent 1.0 alpha version of Datasette to work.

```bash
pip install datasette>=1.0a13
```
Afterwards, install this plugin in the same environment as Datasette.

```bash
datasette install datasette-pins
```

## Configuration

`datasette-pins` stores pins in the [internal database](https://docs.datasette.io/en/latest/internals.html#datasette-s-internal-database). This database runs in-memory by default, which means your pins will be lost if you restart the server. To avoid that, start Datasette with the `--internal` option to specify where that database should be stored on disk:

```bash
datasette mydatabase.db --internal internal.db
```
`datasette-pins` has two permissions `datasette-pins-write` and
`datasette-pins-read`. Actors with the `datasette-pins-write` permissions can
pin and reorder items, while actors with `datasette-pins-read` permissions can
only view pinned items.

Here's an example
[`datasette.yaml` file](https://docs.datasette.io/en/latest/configuration.html#datasette-yaml-reference)
where all actors can view pins, but only the `root` actor can pin items:

```yaml
permissions:
  datasette-pins-read:
    id: "*"
    unauthenticated: true
  datasette-pins-write:
    id: "root"
```

## Usage

Once logged in, the `root` use will see new pin/unpin option under the database,
table, and query actions menu:

<img src="https://datasette-cloud-assets.s3.amazonaws.com/blog/2024/datasette-pins/table-example.png"/>

## Development

To set up this plugin locally, first checkout the code. Then create a new
virtual environment:

```bash
cd datasette-pins
python3 -m venv venv
source venv/bin/activate
```

Now install the dependencies and test dependencies:

```bash
pip install -e '.[test]'
```

To run the tests:

```bash
pytest
```

### Building JavaScript from TypeScript

This plugin includes TypeScript/TSX source files in `datasette_pins/frontend/` that need to be compiled to JavaScript. If you modify any `.ts` or `.tsx` files, you'll need to rebuild the JavaScript.

First install the Node.js dependencies:

```bash
npm install
```

Then build the JavaScript using [just](https://github.com/casey/just):

```bash
just js
```

This uses esbuild to compile and minify the TypeScript files into `datasette_pins/static/`.
in-silico-cancer-cell 0.2.5
Simulation of an electrophysiological A549 cancer cell model using individual ion channels across the membrane
Requires Python: >=3.11

# Electrophysiological Cancer Cell Model

![PyPI - Version](https://img.shields.io/pypi/v/in-silico-cancer-cell)

Attempt to model an A549 cancer cell's ion channels using an HMM (Hidden Markov Model) and simulation of voltage + current development accross the membrane of the cell.

This software comes in three flavours:

- to run the `main.rs` simulation, do `cargo run`,
- to compile the Python module, do `maturin develop --features pyo3`,
- to precompile for the Astro dashboard, do `bun run wasm-pack build frontend`.

## A visual to capture your interest:

![Ion Channels](https://journals.plos.org/ploscompbiol/article/figure/image?size=large&download=&id=10.1371/journal.pcbi.1009091.g002)
(Image source: [here](https://doi.org/10.1371/journal.pcbi.1009091.g002)).

This computational model is based on [Langthaler et al., 2021](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1009091): **A549 in-silico 1.0: A first computational model to simulate cell cycle dependent ion current modulation in the human lung adenocarcinoma**.

## The Simulation Dashboard

![Screenshot of the User Interface](./figures/full-length-screenshot.png)
ampersend-sdk 0.0.7
Python SDK for ampersend

# ampersend-sdk

Python SDK for integrating [x402](https://github.com/coinbase/x402) payment capabilities into A2A (Agent-to-Agent)
protocol applications.

## Quick Start

```python
from ampersend_sdk import create_ampersend_treasurer
from ampersend_sdk.a2a.client import X402RemoteA2aAgent

# Create treasurer (one-liner setup)
treasurer = create_ampersend_treasurer(
    smart_account_address="0x...",
    session_key_private_key="0x...",
)

agent = X402RemoteA2aAgent(
    treasurer=treasurer,
    name="my_agent",
    agent_card="https://agent.example.com/.well-known/agent-card.json",
)

result = await agent.run("your query")
```

## Package Structure

```
ampersend_sdk/
├── a2a/
│   ├── client/          # Client-side x402 support
│   └── server/          # Server-side x402 support
└── x402/                # Core x402 components
    ├── treasurer.py
    └── wallets/         # EOA & Smart Account wallets
```

## Documentation

**→ [Complete Python SDK Documentation](../README.md)**

## Development

```bash
# Test
uv run -- pytest

# Lint & format
uv run -- ruff check python
uv run -- ruff format python

# Type check
uv run -- mypy python
```

## Learn More

- [Python SDK Guide](../README.md)
- [x402 Specification](https://github.com/coinbase/x402)
- [A2A Protocol](https://github.com/anthropics/adk)
langchain-ampersend 0.0.7
LangChain integration for Ampersend x402 payments
Requires Python: >=3.13

# langchain-ampersend

LangChain integration for Ampersend x402 payments. Call remote A2A agents with automatic payment handling.

## Installation

```bash
pip install langchain-ampersend
```

## Usage

```python
from langchain_ampersend import A2AToolkit, create_ampersend_treasurer
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

# Create treasurer (one-liner setup)
treasurer = create_ampersend_treasurer(
    smart_account_address="0x...",
    session_key_private_key="0x...",
)

# Create toolkit for a remote agent
toolkit = A2AToolkit(
    remote_agent_url="https://agent.example.com",
    treasurer=treasurer,
)

# Initialize (discovers the agent)
await toolkit.initialize()

# Use with LangGraph
llm = ChatOpenAI(model="gpt-4")
agent = create_agent(llm, toolkit.get_tools())

# Run
result = await agent.ainvoke({"messages": [("user", "Query some data")]})
```

## Tools

The toolkit provides two tools:

- `a2a_get_agent_details` - Get the capabilities and skills of the remote agent
- `a2a_send_message` - Send a message to the remote agent (payments handled automatically)
eyconf 0.6.2
Easy Yaml based Configuration for Python
Requires Python: >=3.10

<p align="center">
    <h1 align="center">EYConf</h1>
</p>
<p align="center">
    <em><b>E</b>asy <b>Y</B>aml based <b>Conf</b>iguration for Python</em>
</p>


<p align="center">
     <a href="https://pypi.org/project/eyconf/">
        <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/eyconf?style=flat-square">
     </a>
    <a href="https://github.com/semohr/eyconf/actions">
        <img alt="build status" src="https://img.shields.io/github/actions/workflow/status/semohr/eyconf/workflow.yml?style=flat-square" />
    </a>
    <a href="https://eyconf.readthedocs.io/en/latest/">
        <img alt="docs" src="https://img.shields.io/readthedocs/eyconf?style=flat-square" />
    </a>
    <a href="https://github.com/semohr/eyconf/blob/main/LICENSE">
        <img alt="License: GPL v3" src="https://img.shields.io/badge/License-GPL%20v3-blue.svg?style=flat-square" />
    </a>
    <a href="https://codecov.io/github/semohr/eyconf" > 
        <img src="https://codecov.io/github/semohr/eyconf/graph/badge.svg?token=JJVCY9H6QR"/> 
    </a>
</p>


## Why EYConf?

<!-- start features -->
- **Schema-First Configuration**: Define your config structure with Python dataclasses, get automatic YAML generation with comments
- **Type-Safe Access**: Access nested configuration values with full IDE support and runtime type checking
- **Validation First**: Catch configuration errors early with detailed, human-readable validation messages
- **Zero Boilerplate**: No manual YAML parsing, no dictionary access - just clean attribute access to your configuration
<!-- end features -->

## Installation

<!-- start installation -->
You can install EYConf from [PyPI](https://pypi.org/project/eyconf/) using pip.

```bash
pip install eyconf
```
<!-- end installation -->

## Example Usage

<!-- start usage -->

```python
from dataclasses import dataclass
from eyconf import EYConf

@dataclass
class AppConfig:
    """Application configuration"""
    database_url: str = "sqlite:///app.db"
    debug: bool = False

# Creates/loads config.yaml automatically
config = EYConf(AppConfig)

# Use your config
print(config.data.debug)  # False
```

This will create a `config.yaml` file in your current working directory with the following content:

```yaml
# Application configuration

database_url: sqlite:///app.db
debug: false
```
<!-- end usage -->

Please refer to the [documentation](https://eyconf.readthedocs.io/en/latest/) for more examples and detailed usage instructions.
kdenlive 0.0.1
Python SDK for Kdenlive project manipulation (use 'kden' package instead)
Requires Python: >=3.9
Keywords: editing, kdenlive, mlt, subtitle, title, video

# kdenlive

**NOTE: This is a placeholder package. Please use [`kden`](https://pypi.org/project/kden/) instead.**

```bash
pip install kden
```

## About

This package name is reserved to prevent namespace conflicts. The actual SDK is published under the name `kden`.

## License

Apache-2.0
kden 0.0.1
Python SDK for Kdenlive project manipulation
Requires Python: >=3.9
Keywords: editing, kdenlive, mlt, subtitle, title, video

# kden

Python SDK for Kdenlive project manipulation.

## Status: Placeholder

This package is a name reservation. Full implementation coming soon.

## Planned Features

- Load/save Kdenlive (.kdenlive) project files
- Add/remove video tracks programmatically
- Inject title clips with precise timing from subtitle files
- CLI wrapper for common operations

## License

Apache-2.0
snakemake 9.16.3
Workflow management system to create reproducible and scalable data analyses
Requires Python: >=3.11

  Snakemake is a workflow management system that aims to reduce the
  complexity of creating workflows by providing a fast and comfortable
  execution environment, together with a clean and modern specification
  language in python style. Snakemake workflows are essentially Python
  scripts extended by declarative code to define rules. Rules describe
  how to create output files from input files.