semvec/pypi-packages huggingface dataset:
sqltidy 0.6.2
SQL Formatting Made Easy

# SQLTidy

![alt text](https://raw.githubusercontent.com/jrasband-dev/sqltidy/refs/heads/main/sqltidy.svg)

[![PyPI version](https://img.shields.io/pypi/v/sqltidy.svg)](https://pypi.org/project/sqltidy/)  
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)  
[![Documentation Status](https://img.shields.io/badge/docs-online-brightgreen.svg)](https://jrasband-dev.github.io/sqltidy/)

Tidy your SQL Scripts

For full details and usage, see the [official documentation](https://jrasband-dev.github.io/sqltidy/).

## Getting Started

```bash
pip install sqltidy
```
aws-sso-config 0.1.1
A CLI tool to manage AWS SSO configuration using boto3 and Typer.
Requires Python: <=3.14,>=3.12

# AWS SSO Config

A command-line tool to manage AWS SSO credentials and configuration using Typer and Boto3.

## Features
- Retrieve AWS SSO credentials and save them to environment variables and a `.env` file
- Automatically update your AWS config file with SSO settings
- Optionally run SSO login automatically
- Show your current AWS config for a given profile


## Requirements
- Python 3.12+
- [boto3](https://pypi.org/project/boto3/)
- [typer](https://pypi.org/project/typer/)
- [python-dotenv](https://pypi.org/project/python-dotenv/)

## Installation

Install the package in editable/development mode (from the project root):

```powershell
pip install .
```


## Usage

After installation, use the CLI command:

```powershell
aws-connect load-config [OPTIONS]
```

### Example

```powershell
aws-connect load-config --profile myprofile --sso-url https://example.awsapps.com/start --account-id 123456789012 --role-name MyRole --region us-west-2 --sso-region us-east-1 --env-file .env
```

#### Options
- `--profile`, `-p`: AWS SSO profile name (default: `genai`)
- `--sso-url`: SSO start URL
- `--account-id`: AWS account ID
- `--role-name`: SSO role name
- `--region`, `-r`: AWS region
- `--sso-region`: SSO region
- `--session-name`: SSO session name (defaults to profile name)
- `--env-file`: Path to `.env` file (default: `.env`)
- `--auto-login/--no-auto-login`: Automatically run SSO login (default: true)
- `--update-config/--no-update-config`: Update AWS config file (default: true)

### Show Config

```powershell
aws-connect show-config --profile myprofile
```

## How it works
- Updates your AWS config file with SSO settings
- Runs `aws sso login` for the profile (if enabled)
- Retrieves credentials and saves them to environment variables and `.env`

## License
MIT
django-tasks-concurrent 0.1.0
Concurrent async worker for Django Tasks (django-tasks)
Requires Python: >=3.12
Keywords: async, asyncio, concurrent, django, tasks, worker

# django-tasks-concurrent

Concurrent async worker for [Django Tasks](https://github.com/RealOrangeOne/django-tasks).

Runs multiple async tasks concurrently using `asyncio.TaskGroup`. While one task awaits I/O (API calls, database queries), others can execute. Optimized for I/O-bound workloads.

## Installation

```bash
pip install django-tasks-concurrent
```

Add to `INSTALLED_APPS`:

```python
INSTALLED_APPS = [
    ...
    "django_tasks",
    "django_tasks.backends.database",
    "django_tasks_concurrent",
]
```

## Usage

Run the worker:

```bash
# 3 concurrent workers (default)
python manage.py concurrent_worker

# 5 concurrent workers with 0.5s polling interval
python manage.py concurrent_worker --concurrency=5 --interval=0.5

# Specify queue and backend
python manage.py concurrent_worker --queue-name=high-priority --backend=default
```

### Options

| Option | Default | Description |
|--------|---------|-------------|
| `--concurrency` | 3 | Number of concurrent sub-workers |
| `--interval` | 1.0 | Polling interval (seconds) when no tasks |
| `--queue-name` | `settings.TASK_QUEUE_NAME` or "default" | Queue to process |
| `--backend` | "default" | Django Tasks backend name |

## How It Works

The worker spawns N sub-workers as asyncio coroutines. Each sub-worker:

1. Claims a task using `SELECT FOR UPDATE SKIP LOCKED`
2. Executes the task (async tasks run natively, sync tasks via thread pool)
3. Marks task as succeeded/failed
4. Repeats

This allows true concurrent execution of async tasks - while one awaits an API response, others continue processing.

## When to Use

**Use `concurrent_worker` for:**
- I/O-bound tasks (API calls, LLM inference, HTTP requests)
- Tasks that spend most time awaiting external services
- Workloads where you want N tasks running simultaneously

**Use standard `db_worker` for:**
- CPU-bound tasks
- Tasks that don't benefit from async
- Simple sequential processing

## Async Task Example

```python
from django_tasks import task

@task
async def call_llm_api(prompt: str) -> str:
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.anthropic.com/v1/messages",
            json={"prompt": prompt},
        )
        return response.json()["content"]
```

With `--concurrency=3`, three LLM calls can be in-flight simultaneously.

## Requirements

- Python 3.12+
- Django 6.0+
- django-tasks 0.5.0+

## License

MIT
iflow-mcp_maitreyam_gmail-mcp-server 1.0.0
A resilient MCP server built with fastMCP for sending emails through Gmail's SMTP server using AI agents
Requires Python: >=3.8


# Gmail-mcp-server
A resilient MCP server built with fastMCP for sending emails through Gmail's SMTP server using AI agents.
[![smithery badge](https://smithery.ai/badge/@MaitreyaM/gmail-mcp-server)](https://smithery.ai/server/@MaitreyaM/gmail-mcp-server)

## Features

- Send emails via Gmail SMTP
- Fetch recent emails from Gmail folders
- Handle email attachments
- Health check endpoint for deployment monitoring

## Deployment on Smithery.ai

This server is configured for deployment on Smithery.ai using Streamable HTTP transport.

### Configuration

The server requires the following configuration parameters:
- `smtp_username`: Your Gmail email address
- `smtp_password`: Your Gmail app password (not your regular password)

### Health Check

The server provides a health check endpoint at `/health` for Smithery deployment monitoring.


## CLAUDE CONFIG EXAMPLE 
```
{
  "mcpServers": {
    "terminal_server": {
      "command": "/Users/maitreyamishra/.local/bin/uv",
      "args": [
        "--directory", "Path to your mcp server file",
        "run",
        "terminal_server.py"
      ]
    },
    "web3_server": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:3000/mcp"
      ]
    },
    "gmail_mcp": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8989/mcp"
      ]
    }
  }
}
```


### Port

The server runs on port 5000 and binds to all interfaces (0.0.0.0) for container deployment.

## Local Development

1. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

2. Set environment variables:
   ```bash
   export SMTP_USERNAME="your-email@gmail.com"
   export SMTP_PASSWORD="your-app-password"
   ```

3. Run the server:
   ```bash
   python gmail_mcp.py
   ```

## Docker

Build and run with Docker:
```bash
docker build -t gmail-mcp .
docker run -p 5000:5000 -e SMTP_USERNAME=your-email -e SMTP_PASSWORD=your-password gmail-mcp
```
django-unmanaged-forgejo 0.3.0
Unmanaged Django Models for Forgejo
Requires Python: >=3.10

# Unmanaged Django Models for Forgejo

![PyPI - License](https://img.shields.io/pypi/l/django-unmanaged-forgejo)
![PyPI - Version](https://img.shields.io/pypi/v/django-unmanaged-forgejo)

# Installation

```shell
uv add django-unmanaged-forgejo
# or
pip install django-unmanaged-forgejo
```

Configure `settings.py` with correct `INSTALLED_APPS`, `DATABASES`, and `DATABASE_ROUTER`

```python
# Add django_unmanaged_forgejo to installed apps
INSTALLED_APPS = [
    "myapp",
    "django_unmanaged_forgejo", # << Add to installed apps
    # Django
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

# https://docs.djangoproject.com/en/6.0/ref/settings/#databases
DATABASES = {
    "default": env.db_url(
        var="DATABASE_URL",
        default=f"sqlite:///{BASE_DIR}/db.sqlite3",
    ),
    # Configure additional database connection named 'django_unmanaged_forgejo'
    # for the module to use with the router
    "django_unmanaged_forgejo": env.db_url("DATABASE_FORGEJO", default=None),
}

# https://docs.djangoproject.com/en/6.0/ref/settings/#database-routers
# Add the provided router
DATABASE_ROUTERS = ["django_unmanaged_forgejo.router.ForgejoRouter"]
```
twitch-client 0.2.0
Twitch OAuth client with token management and authenticated HTTP requests
Requires Python: <4.0,>=3.10

# twitch-client

[![PyPI](https://img.shields.io/pypi/v/twitch-client)](https://pypi.org/project/twitch-client/)

Twitch OAuth client with token management and authenticated HTTP requests for the Twitch Helix API.

## Installation

```bash
pip install twitch-client
```

## Credentials Setup

### 1. Get Client ID & Secret

1. Go to [Twitch Developer Console](https://dev.twitch.tv/console/apps)
2. Create or select your application
3. Copy the **Client ID** and generate a **Client Secret**

### 2. Get Access & Refresh Tokens

Use the [Twitch CLI](https://dev.twitch.tv/docs/cli/) or an OAuth flow to get tokens:

```bash
twitch token -u -s "chat:read chat:edit channel:manage:broadcast"
```

### 3. Create `.env` File

Create `~/.twitch-secrets/.env` (default location):

```bash
mkdir -p ~/.twitch-secrets
cat > ~/.twitch-secrets/.env << 'EOF'
TWITCH_CLIENT_ID=your_client_id
TWITCH_CLIENT_SECRET=your_client_secret
TWITCH_ACCESS_TOKEN=your_access_token
TWITCH_REFRESH_TOKEN=your_refresh_token
EOF
```

Or set the `TWITCH_ENV_FILE` environment variable to use a custom path.

### Basic Usage

```python
import asyncio
from twitch_client import TwitchHTTPClient

async def main():
    async with TwitchHTTPClient() as client:
        # Get user info
        response = await client.get("/users", params={"login": "twitch"})
        print(response)

asyncio.run(main())
```

### Manual Token Management

```python
from twitch_client import TwitchAuth, TwitchCredentials

async def main():
    # Load credentials
    credentials = TwitchCredentials()

    # Create auth manager
    async with TwitchAuth(credentials) as auth:
        # Get valid token (refreshes automatically if needed)
        token = await auth.get_token()

        # Get token info including scopes
        info = await auth.get_token_info()
        print(f"Scopes: {info.scopes}")

asyncio.run(main())
```

### Custom Credentials Location

```python
import os
os.environ["TWITCH_ENV_FILE"] = "~/my-secrets/.env"

from twitch_client import TwitchHTTPClient
# Will load from custom .env location
```

## Features

- Automatic token refresh before expiration
- Pydantic-based configuration validation
- Async HTTP client with httpx
- Rate limit handling
- Comprehensive error types

## API

### TwitchHTTPClient

The main HTTP client for making authenticated requests:

- `get(endpoint, params)` - GET request
- `post(endpoint, data, params)` - POST request
- `patch(endpoint, data, params)` - PATCH request
- `put(endpoint, data, params)` - PUT request
- `delete(endpoint, params)` - DELETE request

### TwitchAuth

Token management:

- `get_token()` - Get valid access token
- `refresh_token()` - Force token refresh
- `get_token_info()` - Get token metadata and scopes

## Exceptions

- `TwitchClientError` - Base exception
- `TwitchAuthError` - Authentication errors
- `TwitchTokenRefreshError` - Token refresh failed
- `TwitchAPIError` - API request failed
- `TwitchRateLimitError` - Rate limit exceeded
iflow-mcp_giannisanni_kokoro-tts-mcp 0.1.1
Add your description here
Requires Python: >=3.10

# Kokoro TTS MCP Server

A Model Context Protocol (MCP) server that provides text-to-speech capabilities using the Kokoro TTS engine. This server exposes TTS functionality through MCP tools, making it easy to integrate speech synthesis into your applications.

## Prerequisites

- Python 3.10 or higher
- `uv` package manager

## Installation

1. First, install the `uv` package manager:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

2. Clone this repository and install dependencies:

```bash
uv venv
source .venv/bin/activate  # On Windows, use: .venv\Scripts\activate
uv pip install .
```

## Features

- Text-to-speech synthesis with customizable voices
- Adjustable speech speed
- Support for saving audio to files or direct playback
- Cross-platform audio playback support (Windows, macOS, Linux)

## Usage

The server provides a single MCP tool `generate_speech` with the following parameters:

- `text` (required): The text to convert to speech
- `voice` (optional): Voice to use for synthesis (default: "af_heart")
- `speed` (optional): Speech speed multiplier (default: 1.0)
- `save_path` (optional): Directory to save audio files
- `play_audio` (optional): Whether to play the audio immediately (default: False)

### Example Usage

```python
from mcp.client import Client

async with Client() as client:
    await client.connect("kokoro-tts")
    
    # Generate and play speech
    result = await client.call_tool(
        "generate_speech",
        {
            "text": "Hello, world!",
            "voice": "af_heart",
            "speed": 1.0,
            "play_audio": True
        }
    )
```

## Dependencies

- kokoro >= 0.8.4
- mcp[cli] >= 1.3.0
- soundfile >= 0.13.1

## Platform Support

Audio playback is supported on:
- Windows (using `start`)
- macOS (using `afplay`)
- Linux (using `aplay`)

## MCP Configuration

Add the following configuration to your MCP settings file:

```json
{
  "mcpServers": {
    "kokoro-tts": {
      "command": "/Users/giannisan/pinokio/bin/miniconda/bin/uv",
      "args": [
        "--directory",
        "/Users/giannisan/Documents/Cline/MCP/kokoro-tts-mcp",
        "run",
        "tts-mcp.py"
      ]
    }
  }
}
```

## License

[Add your license information here]
ffmpeg-tools 0.1.7
A Python package for high-quality FFmpeg command generation and video utilities.
Requires Python: >=3.7

# FFmpeg Tools

A Python package for simplified FFmpeg command generation, video downloading, and file management.

## Installation

```bash
pip install ffmpeg-tools
```

## Usage

### 1. Generating & Running FFmpeg Commands

```python
from ffmpeg_tools import build_command, run_command

# 1. Build the command
cmd = build_command("compress_high_quality", input="video.mp4", output="compressed.mp4")

# 2. Run the command (returns True if successful)
success = run_command(cmd)

# Optional: Dry run to just print the command
run_command(cmd, dry_run=True)
```

### 2. Custom Commands (Dynamic JSON)

You can add your own FFmpeg command templates without modifying the package source.

```python
from ffmpeg_tools.commands import add_command, build_command

# Add a new command template
add_command(
    name="my_custom_encode",
    command=["ffmpeg", "-y", "-i", "{input}", "-c:v", "libx264", "-preset", "fast", "{output}"],
    description="My custom fast encoding profile"
)

# Use the new command
cmd = build_command("my_custom_encode", input="video.mp4", output="video_fast.mp4")
```

The commands are stored in `commands.json` in the package directory.

```python
from ffmpeg_tools import list_commands

# Print all available commands
list_commands()
```

### 3. Downloading Videos

```python
from pathlib import Path
from ffmpeg_tools import download_video

# Download a video from YouTube
download_video(
    url="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    output_folder=Path("downloads"),
    clear_folder=False
)
```

### 4. Cleaning Filenames

```python
from pathlib import Path
from ffmpeg_tools import clean_filename

file_path = Path("downloads/My Video (2024).mp4")
new_path = clean_filename(file_path)
print(new_path)
# Output: downloads/My_Video_2024.mp4
```

## License

MIT