semvec/pypi-packages huggingface dataset:
pylibvpx 1.0.3
Python bindings for libvpx
Requires Python: >=3.11

# Python `libvpx` bindings
Python bindings for VPX encoding/decoding library

# Build with dependencies from lockfile
```shell
uv sync --no-install-project
uv build --wheel --no-build-isolation
```

# Develop with auto rebuild
```shell
uv sync
uv run pytest
```
mcp-motorsportdata 0.0.0
MCP Motorsport data for some racing APIs such as F1, WEC, INDY or NASCAR
Requires Python: >=3.12

# 🏎️ MCP Server F1Data

<img src="./content/example.gif" width="1000">

A Model Context Protocol (MCP) server for interacting with F1Data through LLM interfaces like Claude. **You will need to have Claude installed on your system to continue.**

## Getting Started
First of all, you need to install `mcp-f1data` package from pypi with pip, using the following command:
```commandline
pip install mcp-f1data
```

To use `mcp-f1data` server in claude can be configured by adding the following to your configuration file.
- Windows: `%APPDATA%/Claude/claude_desktop_config.json`
- Linux: `~/Library/Application Support/Claude/claude_desktop_config.json`

Add the F1Data MCP server configuration:
```json
{
  "mcpServers": {
    "mcp-f1data": {
        "command": "python",
        "args": [ "-m", "mcp-f1data" ]
    }
  }
}
```

## Tools 
- `fastest lap`
- `lap`
- `top speed`
- `total laps`
- `driver team`
- `team driver`
- `box laps`
- `deleted laps`

## Instalation
Active the virtual environment and install the requirements using:
```commandline
.\.venv\Scripts\activate
```

Install the mcp server in Claude using the following command:
```commandline
mcp install .\server.py
```

## Requirements
The requirementes used to build this MCP server are:
- `fastf1`
- `pandas`
- `fastmcp`
- `websockets`
- `mcp`
- `pydantic`

## Testing 
You can test the server using the MCP Inspector:
```commandline
mcp dev .\server.py
```

## License
This project is licensed under the MIT <a href="https://github.com/Maxbleu/mcp-f1data/blob/master/LICENSE">LICENSE</a> - see the details.
airchief 0.0.2
Namespace reservation - coming soon
Requires Python: >=3.8

# AIRCHIEF

Placeholder - not published yet.

## Installation

```bash
# YOLO
curl -fsSL https://airchief.ai/install | bash

# Package managers
npm i -g airchief@latest                     # or bun/pnpm/yarn
brew install shaneholloman/tap/airchief      # macOS
```

> **Note:** Remove versions older than 0.1.x before installing

### Documentation

For more info on how to configure airchief [**head over to our docs**](https://airchief.ai/docs).

### Contributing

To run airchief locally you need.

- Bun
- Golang 1.24.x

And run.

```bash
bun install
bun run packages/airchief/src/index.ts
```

#### Development Notes

**API Client Generation**: After making changes to the TypeScript API endpoints in `packages/airchief/src/server/server.ts`, you need to regenerate the Go client and OpenAPI specification:

```bash
cd packages/tui
go generate ./pkg/client/
```

This updates the generated Go client code that the TUI uses to communicate with the backend server.

### FAQ

#### How is this different than Claude Code?

It's very similar to Claude Code in terms of capability. Here are the key differences:

- 100% open source
- Not coupled to any provider. Although Anthropic is recommended, airchief can be used with OpenAI, Google or even local models. As models evolve the gaps between them will close and pricing will drop so being provider agnostic is important.
- A focus on TUI. airchief is built by neovim users and the creators of [terminal.shop](https://terminal.shop); we are going to push the limits of what's possible in the terminal.
- A client/server architecture. This for example can allow airchief to run on your computer, while you can drive it remotely from a mobile app. Meaning that the TUI frontend is just one of the possible clients.
telegram_libs 0.1.38
Common libraries for Telegram bots
Requires Python: <4.0,>=3.11

# Telegram Libs

A framework to build Telegram bots fast.
Common functionality for Andrey Gritsaenko's Telegram bots.

## Installation

```bash
pip install telegram-libs
```

## Bots using this framework

- [Remove Background](https://t.me/MagMediaBot)
- [Upscale Image](https://t.me/UpscaleImageGBot)
- [Generate Background](https://t.me/GenerateBackgroundGBot)
- [Recommend Place to Visit](https://t.me/kudapoyti_go_bot)
- [Try On Outfit](https://t.me/TryOnOutfitGBot)
- [Clone Voice, Text to Speech AI](https://t.me/CloneVoiceAIGBot)
seleniumuser 1.1.4
Selenium wrapper to streamline usage.
Requires Python: >=3.10
Keywords: automation, selenium, webscraping

# Seleniumuser
A module that sits ontop of Selenium to streamline scraping and automation workflows.<br>
Install with:
<pre>pip install seleniumuser</pre>
Currently supports using firefox or chrome.<br>
You will need to have the appropriate web driver executable for the browser and your system in either the system PATH or a location passed to the User class constructor.<br>
They can be found here:<br>
[Firefox](https://github.com/mozilla/geckodriver/releases)<br>
[Chrome](https://chromedriver.chromium.org/downloads)

### Basic usage: 

#####  Submitting a generic form with fields for first name, last name, email address, and phone number:

<pre>
from seleniumuser import User
user = User(browser_type="firefox")
user.get('https://somewebsite.com')
user.send_keys('//input[@id="first-name"]', 'Bill')
user.fill_next(['Billson', 'bill@bill.com', '5345548486'])
user.click('//button[@id="submit"]')
try:
    user.wait_until(lambda: 'Submission Received' in user.text('//p[@id="confirmation-message"]'))
    print('Submission success.')
except TimeoutError:
    print('Submission failed.')
user.close_browser()
</pre>

The User class supports being used with a context manager if you'd rather not worry about closing the browser before exiting the script:

<pre>
from seleniumUser import User
with User(browser_type="firefox") as user:
    user.get('https://somewebsite.com')
    user.send_keys('//input[@id="first-name"]', 'Bill')
    user.fill_next(['Billson', 'bill@bill.com', '5345548486'])
    user.click('//button[@id="submit"]')
    try:
        user.wait_until(lambda: 'Submission Received' in user.text('//p[@id="confirmation-message"]'))
        print('Submission success.')
    except TimeoutError:
        print('Submission failed.')
</pre>
dikshantnetvoice 0.2.5
Offline voice-controlled networking toolkit
Requires Python: >=3.7

# DikshantNetVoice

[![PyPI version](https://img.shields.io/pypi/v/dikshantnetvoice)](https://pypi.org/project/dikshantnetvoice/)
[![Python versions](https://img.shields.io/pypi/pyversions/dikshantnetvoice)](https://pypi.org/project/dikshantnetvoice/)
[![License](https://img.shields.io/pypi/l/dikshantnetvoice)](https://pypi.org/project/dikshantnetvoice/)

**Offline voice-controlled networking toolkit for developers and IT professionals.**

## Features

- 🎤 Voice Commands for common networking tasks
- 🌐 Cross-Platform (Windows/Linux/macOS)
- 🔒 100% Offline - No internet required after installation
- ⚡ Fast Execution with native system commands

## Installation

```bash
pip install dikshantnetvoice
```

**Note**: Requires Python 3.7+ and a working microphone.

## Quick Start

```python
from dikshantnetvoice import VoiceEngine

engine = VoiceEngine()
print("Say 'check my IP' or 'scan ports 1 to 100'")
print(engine.listen())  # Returns command results
```

## Supported Voice Commands

- "check my IP" — Shows all interface IPs
- "scan ports X to Y" — Scans ports in the given range
- "ping google.com" — Tests internet connectivity
- "list WiFi networks" — Displays available wireless networks
- "is port 80 open" — Checks if a specific port is open

## Advanced Usage

```python
from dikshantnetvoice import NetworkCommands

# Manual command execution
print(NetworkCommands().list_wifi())
print(NetworkCommands().traceroute("github.com"))
```

## Documentation

Full API reference and usage guide available on the GitHub Wiki.

## License

MIT License. See the `LICENSE` file for more information.
Logita 1.0.0
A simple and colorful logging utility for console and file logging.
Requires Python: >=3.6


# Loggy

Loggy is a simple and colorful logging utility for console and file logging in Python.

## Features

- Colored console output for different log levels
- Optional file logging with customizable filename
- Supports common log levels: info, success, error, warning, debug, critical, exception
- Easy to use and integrate into your projects

## Installation

```bash
pip install logita
```

Then include Logita in your project.

## Usage

```python
from Logita import Logita

logger = Loggy(log_to_file=True, log_filename="app.log")
logger.info("This is an info message")
logger.success("This is a success message")
logger.error("This is an error message")
```

## License

This project is licensed under the MIT License.
contextguard 0.1.2
Context-aware decorator to prevent repeated API retries using Redis.
Requires Python: >=3.7

# ContextGuard 🛡️
A plug-and-play decorator to guard your API calls and background tasks using Redis-based context awareness.

## 🚀 Features
- ✅ Prevent retrying recent failures (e.g., rate limits, flaky APIs)
- 🔄 Auto-reset after TTL
- ⚡ Works for both `sync` and `async` functions
- 🎯 Supports dynamic TTL logic
- 🧠 Skips re-execution on recent success (optional)
- 🧰 Namespace-safe Redis keys

## 📦 Installation
```bash
pip install redis
```

## 🧑‍💻 Usage

### For Sync Functions
```python
@context_guard(lambda x: f"zoom:{x}", ttl=60)
def call_api(x):
    raise Exception("Rate limit error")
```

### For Async Functions
```python
@context_guard(lambda x: f"zoom:{x}", ttl=60)
async def async_call_api(x):
    raise Exception("Async rate limit error")
```

## 🔁 Options
- `ttl`: static fallback TTL
- `ttl_fn`: dynamic TTL per invocation
- `skip_on_success=True`: also skip recent successes
- `store_metadata=True`: return `cached_at` and `elapsed` info
- `redis_client`: custom Redis instance

## ✅ Ideal Use Cases
- Avoiding rate-limit loops (Zoom, Gmail, Slack, etc.)
- Skipping repeat ETL calls in Airflow or workers
- Backoff logic without external libraries