semvec/pypi-packages huggingface dataset:
YT-Nebula 1.0.3
una herramienta mela para youtube
Requires Python: >=3.8

# 🌌 YT-NEBULA

**yt-nebula** is a terminal UI (TUI) for downloading YouTube music and videos with zero friction. Built for speed, privacy, and ease of use.

## 🚀 Features
* **One-click sync:** Just search, hit enter, and nebula does the rest.
* **High-quality formats:** Choose between MP3 (Audio) and MP4 (Video).
* **Automatic Metadata:** Every download includes thumbnails and song tags (Artist, Title).

## 🛠️ Installation

### 1. Prerequisites
You **must** have `ffmpeg` installed on your system for audio conversion and video merging.

* **Fedora/RHEL:** `sudo dnf install ffmpeg`
* **Ubuntu/Debian:** `sudo apt install ffmpeg`
* **Arch Linux:** `sudo pacman -S ffmpeg`

### 2. Install Nebula
Clone the repo and install it locally:

```bash
git clone https://github.com/andrestube/yt-nebula.git
cd yt-nebula
pip install .
```

## ⚖️ License
MIT License - feel free to use and modify.
wsp-cheval 0.3.1
High-performance discrete-choice (logit) travel demand model evaluation
Requires Python: <3.11,>=3.9

# Cheval (wsp-cheval)

Cheval is a Python package for high-performance evaluation of discrete-choice (logit) models. It's largely built upon the Pandas, NumPy, and NumExpr packages; along with some custom Numba code for performance-critical bottlenecks.

The name is an acronym for "CHoice EVALuator" but has a double-meaning as _cheval_ is the French word for "horse" - and this package has a lot of horsepower! It has been designed for use in travel demand modelling, specifically microsimulated discrete choice models that need to process hundreds of thousands of records through a logit model. It also supports "stochastic" models, where the probabilities are the key outputs.

> [!IMPORTANT]
> As of v0.3, this package is imported using `wsp_cheval` instead of `cheval`

## Key features

Cheval contains two main components:

- `cheval.ChoiceModel` which is the main entry point for discrete choice modelling
- `cheval.LinkedDataFrame` which helps to simplify complex utility calculations.

These components can be used together or separately.

Cheval is compatible with Python 3.7+

## Installation

Cheval can be installed with the following command:

```batch
pip install wsp-cheval
```

### With `pip` directly from GitHub

Cheval can be installed directly from GitHub using `pip` by running the following command:

```batch
pip install git+https://github.com/wsp-sag/wsp-cheval.git
```
a2a-handler 0.1.15
An A2A Protocol client TUI and CLI.
Requires Python: >=3.11
Keywords: a2a, a2a-protocol, agent, agent-to-agent, ai, cli, tui

# Handler

[![CI](https://github.com/alDuncanson/handler/actions/workflows/ci.yml/badge.svg)](https://github.com/alDuncanson/handler/actions/workflows/ci.yml)
[![A2A Protocol](https://img.shields.io/badge/A2A_Protocol-v0.3.0-blue)](https://a2a-protocol.org/latest/)
[![PyPI version](https://img.shields.io/pypi/v/a2a-handler)](https://pypi.org/project/a2a-handler/)
[![PyPI - Status](https://img.shields.io/pypi/status/a2a-handler)](https://pypi.org/project/a2a-handler/)
[![PyPI monthly downloads](https://img.shields.io/pypi/dm/a2a-handler)](https://pypi.org/project/a2a-handler/)
[![Pepy total downloads](https://img.shields.io/pepy/dt/a2a-handler?label=total%20downloads)](https://pepy.tech/projects/a2a-handler)
[![GitHub stars](https://img.shields.io/github/stars/alDuncanson/handler)](https://github.com/alDuncanson/handler/stargazers)

![Handler TUI](https://github.com/alDuncanson/Handler/blob/main/assets/handler-tui.png?raw=true)

Handler is an open-source [A2A Protocol](https://github.com/a2aproject/A2A)
client and developer toolkit.

It provides a CLI and TUI for communicating with remote agents, an MCP server
for bridging AI assistants into the A2A ecosystem, a reference server agent
implementation, push notification support, and agent card validation. Whether
you're building agents, integrating with existing ones, or exploring
agent-to-agent communication, Handler gives you the observability and control
you need from your terminal.

## Who is Handler For?

Handler is for developers, researchers, and teams working with AI agents. If
you're building agents that speak A2A, Handler helps you test and debug them. If
you're integrating with existing A2A agents, Handler gives you a fast way to
explore their capabilities. If you want your AI assistant to communicate with
other agents, Handler's MCP server bridges that gap. And if you're just curious
about agent-to-agent communication, Handler is a great place to start.

## Get Started

### Install

Install with [uv](https://github.com/astral-sh/uv):

```bash
uv tool install a2a-handler
```

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

```bash
pipx install a2a-handler
```

Or with pip:

```bash
pip install a2a-handler
```

### Run

Or, run from an ephemeral environment:

```bash
# With uv
uvx --from a2a-handler handler

# With pipx
pipx run a2a-handler
```

### Development Environment

A [hermetically sealed](https://zero-to-nix.com/concepts/hermeticity/)
development environment is available with
[Nix](https://zero-to-nix.com/concepts/nix/):

```bash
nix develop
```

This provides Python, uv, and just with all commands ready to use.

For usage documentation, see the
[Handler docs](https://alduncanson.github.io/Handler/).

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).
langgraph-checkpoint-sqlite 3.0.3
Library with a SQLite implementation of LangGraph checkpoint saver.
Requires Python: >=3.10

# LangGraph SQLite Checkpoint

Implementation of LangGraph CheckpointSaver that uses SQLite DB (both sync and async, via `aiosqlite`)

## Usage

```python
from langgraph.checkpoint.sqlite import SqliteSaver

write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}

with SqliteSaver.from_conn_string(":memory:") as checkpointer:
    checkpoint = {
        "v": 4,
        "ts": "2024-07-31T20:14:19.804150+00:00",
        "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
        "channel_values": {
            "my_key": "meow",
            "node": "node"
        },
        "channel_versions": {
            "__start__": 2,
            "my_key": 3,
            "start:node": 3,
            "node": 3
        },
        "versions_seen": {
            "__input__": {},
            "__start__": {
                "__start__": 1
            },
            "node": {
                "start:node": 2
            }
        },
    }

    # store checkpoint
    checkpointer.put(write_config, checkpoint, {}, {})

    # load checkpoint
    checkpointer.get(read_config)

    # list checkpoints
    list(checkpointer.list(read_config))
```

### Async

```python
from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver

async with AsyncSqliteSaver.from_conn_string(":memory:") as checkpointer:
    checkpoint = {
        "v": 4,
        "ts": "2024-07-31T20:14:19.804150+00:00",
        "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
        "channel_values": {
            "my_key": "meow",
            "node": "node"
        },
        "channel_versions": {
            "__start__": 2,
            "my_key": 3,
            "start:node": 3,
            "node": 3
        },
        "versions_seen": {
            "__input__": {},
            "__start__": {
                "__start__": 1
            },
            "node": {
                "start:node": 2
            }
        },
    }

    # store checkpoint
    await checkpointer.aput(write_config, checkpoint, {}, {})

    # load checkpoint
    await checkpointer.aget(read_config)

    # list checkpoints
    [c async for c in checkpointer.alist(read_config)]
```
create-vibe-app 0.1.0
A CLI tool to scaffold Vibe Coding projects
Requires Python: >=3.8

# 🎸 create-vibe-app

Scaffold AI-friendly project structures for **Vibe Coding** – a methodology that helps AI agents work more effectively on your codebase.

## ✨ What is Vibe Coding?

Vibe Coding is a development approach where:
- **AI agents** handle implementation based on clear structures
- **Knowledge compounds** through wiki and experience recording
- **Complexity-based routing** ensures the right workflow for each task

## 📦 Installation

```bash
pip install create-vibe-app
```

## 🚀 Usage

```bash
create-vibe-app my-project
cd my-project
code .
```

Then in your AI assistant:
> "Read MAIN.md, then help me build [your idea]"

## 📁 Generated Structure

```
my-project/
├── MAIN.md           # Project entry point
├── agent/            # AI agent definitions
│   ├── phase-router.md
│   ├── requirement-manager.md
│   ├── design-manager.md
│   ├── implementation-executor.md
│   └── experience-depositor.md
├── skill/            # Reusable workflow skills (10)
├── wiki/             # Project knowledge base
├── requirement/      # Task tracking
├── mcp/              # External tool configs
├── code/             # Your source code
└── reference/        # Reference implementations
```

## 🔄 Workflow

```
User Task → Analyze Intent → Detect Complexity → Route → Update Knowledge
                                ↓
                    Simple: Direct execution
                    Medium: Requirement → Design → Implement
                    Complex: Full flow + User confirmation
```

## 🤝 Contributing

Issues and PRs welcome!

## 📄 License

MIT
covers 0.0.5.dev202601181928
Near Zero-Overhead Python Code Coverage
Requires Python: <3.15,>=3.12
Keywords: coverage, testing

# Covers: Near Zero-Overhead Python Code Coverage

Covers is a fast Python code coverage tool, originally based on [SlipCover](httpshttps://github.com/plasma-umass/slipcover).
This version has been re-written as a Rust / PyO3 extension for improved performance and maintainability.

[![license](https://img.shields.io/github/license/amartani/covers?color=blue)](LICENSE)
[![pypi](https://img.shields.io/pypi/v/covers?color=blue)](https://pypi.org/project/covers/)
![pyversions](https://img.shields.io/pypi/pyversions/covers?logo=python&logoColor=FBE072)
![tests](https://github.com/amartani/covers/workflows/tests/badge.svg)

## About Covers
Covers is a fast [code coverage](https://en.wikipedia.org/wiki/Code_coverage) tool.
It tracks a Python program as it runs and reports on the parts that executed and
those that didn't.
That can help guide your testing (showing code that isn't being tested), debugging,
[fuzzing](https://en.wikipedia.org/wiki/Fuzzing) or to find "dead" code.

Past code coverage tools can make programs significantly slower;
it is not uncommon for them to take twice as long to execute.
Covers aims to provide the same information with **near-zero overhead**, often
almost as fast as running the original Python program.

### How it works
Previous coverage tools like [Coverage.py](https://github.com/nedbat/coveragepy) rely on 
[Python's tracing facilities](https://docs.python.org/3/library/sys.html?highlight=settrace#sys.settrace),
which add significant overhead.
Instead, Covers uses the new
[`sys.monitoring`](https://docs.python.org/3.12/library/sys.monitoring.html) API
to collect coverage information with minimal performance impact. The core data collection
is implemented in Rust for maximum efficiency.

## Getting started
Covers is available from [PyPI](https://pypi.org/project/covers).
You can install it like any other Python module with
```console
pip3 install covers
```

You could then run your Python script with:
```console
python3 -m covers myscript.py
```

### Using it with a test harness
Covers can also execute a Python module, as in:
```console
python3 -m covers -m pytest -x -v
```
which starts `pytest`, passing it any options (`-x -v` in this example)
after the module name.
No plug-in is required for pytest.

## Platforms
Our GitHub workflows run the automated test suite on Linux, MacOS and Windows, but
really it should work anywhere where CPython does.

## Contributing
Covers is under active development; contributions are welcome!
Please also feel free to [create a new issue](https://github.com/amartani/covers/issues/new)
with any suggestions or issues you may encounter.
sdtp 2026.1.18
Simple Data Transfer Protocol (SDTP) reference implementation
Requires Python: >=3.8

#  The Simple Data Transfer Protcol

This is a reference server and library  for the Simple Data Transfer Protocol.  It demonstrates the Simple Data Transfer Protocol Server API.  It also functions as an open framework, so new Tables can be attached to the Simple Data Transfer Protocol server by providing a Class with a `get_rows()` method and a `schema` property.
The README.md file in each directory gives the documentation for the utilities and classes in that directory.  

The structure is as follows:
```
├── sdtp
│   ├── sdtp_server: A reference SDTP server and middleware
│   ├── sdtp: The basic SDTP types, including Filters and Tables
```
  
# The Simple Data Transfer Protocol

The SDTP Server implements the Simple Data Transfer Protocol, a universal way to query and transmit tabular data.  The SDTP uses http/https as the underlying transport protocol.  There is no client; rather, a program accessing an SDTP server creates a `RemoteSDMLTable` (see `sdtp.sdtp_table.py`) and accesses that through the standard SDTP Table methods.

This is a quick summary of the Simple Data Transfer Protocol.  A more extended description can be found at:


## Basic Data Structure
The core data structure of the SDTP is a _table_, which is simply a list of list of values. Conceptually, it is equivalent to a SQL database table; each column has a specific type and each row is of the same, fixed length.  The Python definitions are in sdtp.sdtp_table.py.  `type` and `schema` are  the only mandatory entries for a table.  `type` is a strng specifying the table table.  `schema` is a list of columns, each of which is a dictionary with two mandatory fields: `name` and `type`.  Other fields (e.g., to express units or other metadata) are permitted.

The Python implementation of table types is in  `sdtp.sdtp_table.py`

### Simple Data Transfer Protocol Data Types
This is a list of the permissible types.  Each column of a table is of one of these types
See sdtp.sdtp_utils.py.  The native types these convert to are language-specific
1. SDML_STRING: A string.  In Python, class str.
2. SDML_NUMBER: A real or an integer.  In Python, class float or class int.
3. SDML_BOOLEAN: true or false. In Python, class bool.
4. SDML_DATE: A date.  In Python, class datetime.date
5. SDML_DATETIME: A datetime.  In Python, class datetime.datetime
6. SDML_TIME_OF_DAY: A time.  In Python, class datetime.time