semvec/pypi-packages huggingface dataset:
loudstream 0.3.2
Python wrapper for libebur128 with streaming support
Requires Python: >=3.11
Keywords: audio, loudness, EBU R128, libebur128

# loudstream

A file-streaming Python API around [libebur128](https://github.com/jiixyj/libebur128/tree/master/ebur128).

## Install

```bash
pip install loudstream

# OR

uv add loudstream
```

## Usage

```python
from loudstream import Meter

lufs, peak = Meter().measure("some-file.wav")
```

## Running Tests

```bash
uv venv
uv pip install .
uv run pytest -v
```
gemini-all-for-one 1.0.2
A comprehensive AI image platform powered by Google's Gemini AI
Requires Python: >=3.8
Keywords: ai artificial-intelligence image-generation image-analysis image-editing gemini google multimodal chat


# Gemini All-for-One

A comprehensive AI image platform powered by Google's Gemini AI. Provides image generation, analysis, editing, and multimodal chat capabilities.

## Features

- **High-Quality Image Generation**: Text-to-image generation with multiple artistic styles and aspect ratios
- **Advanced Image Analysis**: Intelligent image understanding and detailed descriptions
- **AI-Powered Image Editing**: Edit images while preserving the same object using text prompts
- **Multimodal Chat**: Conversations with text and image support using Gemini AI
- **Free Image Generation**: Alternative image generation via Pollinations.ai (no API key required)
- **Serverless Ready**: Base64 I/O implementation perfect for serverless deployments

## Quick Start

```python
from gemini_all_for_one import ImageGenerator, ImageAnalyzer, ImageEditor, GeminiChatClient

# Generate images
generator = ImageGenerator()
result = generator.generate_image("A beautiful sunset over mountains")
image_data = result['image_base64']

# Analyze images  
analyzer = ImageAnalyzer()
analysis = analyzer.analyze_image(image_bytes)

# Edit images (preserves same object)
editor = ImageEditor()
edited = editor.edit_image(image_bytes, "add sunglasses")

# Multimodal chat
chat = GeminiChatClient()
response = chat.send_message("What's in this image?", image=image_bytes)
```

## Requirements

- Python 3.8+
- Google Gemini API key (get one at https://aistudio.google.com/app/apikey)
- Set `GEMINI_API_KEY` environment variable

## Installation

```bash
pip install gemini-all-for-one
```

## License

MIT License - see LICENSE file for details.
fast-python-events 1.0.0
A high-performance domain events library for Python applications.
Requires Python: >=3.8
Keywords: events, domain, django, fastapi, celery, performance

# Domain Events ⚡

Ultra-fast events system for Python, optimized for high performance and production-ready.

## Features

- 🚀 **7-8x faster** than Django Signals
- 💾 **Memory-efficient** 60% less usage compared to Django Signals
- 🔧 **Type-safe** with DTOs
- 🎯 **Simple and robust**
- 🔌 **Celery integration**

## Installation

### Core dependencies
```bash
pip install -r requirements/requirements.txt
```

### Cython acceleration (recommended for production)
Build and install the Cython module in editable mode so it's available throughout your environment:
```bash
pip install cython
pip install -e ./cython_core
```
This will compile and link the accelerated module automatically. No need to modify PYTHONPATH.

### Development dependencies
Includes everything needed for testing, benchmarks and development:
```bash
pip install -r requirements/requirements-dev.txt
```

## Quick Start

```python
from domain_events import DomainEventSystem, DomainEvent
from dataclasses import dataclass

@dataclass(frozen=True)
class UserRegisteredEvent(DomainEvent):
    event_type = "user.registered"
    user_id: int
    email: str

system = DomainEventSystem()

def send_welcome_email(event: UserRegisteredEvent):
    print(f"Welcome {event.email}!")

system.register_event(
    "user.registered",
    UserRegisteredEvent,
    [(send_welcome_email, {"async": True})]
)

event = UserRegisteredEvent(user_id=1, email="test@example.com")
system.publish(event)
```

## Python Integration

In your code:

```python
from domain_events import domain_events

domain_events.publish(user_event)
```

## Celery Integration

```python
from domain_events import DomainEventSystem
from celery import Celery

app = Celery()
event_system = DomainEventSystem(celery_app=app)
```

## Performance

- **Lookup:** 40-60ns (8x faster than Django Signals)
- **Dispatch (Cython):** 90-120ns per handler (typically 2-10x faster than pure Python)
- **Bulk dispatch (Cython):** up to 10x faster for large batches
- **Memory:** 60% less usage compared to Django Signals
- **Benchmark results:**
    - Cython event dispatch: ~110ns per handler (10 handlers, single event)
    - Python event dispatch: ~170ns per handler (10 handlers, single event)
    - Cython bulk dispatch: ~25μs for 1000 events
    - Python bulk dispatch: ~88μs for 1000 events

For best results in production, always enable Cython acceleration.
httpx-sap-launchpad 0.1.1
httpx Authentication for the SAP Launchpad API
Requires Python: >=3.10

# httpx-sap-launchpad

This library provides [httpx](https://www.python-httpx.org/) [Authentication](https://www.python-httpx.org/advanced/authentication/) for the _SAP Launchpad API_, primarily focusing on downloading software and files from the _SAP_ _Software Download Center_ and _Maintenance Planner_.

This library is not affiliated with _SAP_ in any way.

> ⚠️ **Warning**: This library is not verified to work as I don't have access to an SAP account anymore. If problems are to be discovered I'd be happy to provide guidance and fixes, but that also means I'd need credentials to replicate the issue.

## Install

Install with your package manager of choice:

```shell
pip install httpx-sap-launchpad
```

## Usage

`SAPLaunchpadAuth` extends the `httpx.Auth` class, so the usage is simple:

```python
import httpx
from httpx_sap_launchpad import URL_LAUNCHPAD, SAPLaunchpadAuth


def main() -> None:
    auth = SAPLaunchpadAuth(
        user_id='S1234567890',
        password='password',
    )
    httpx.get(f'{URL_LAUNCHPAD}/applications/softwarecenter/version.json', auth=auth)


if __name__ == '__main__':
    main()
```

`SAPLaunchpadAuth` can be used in conjunction with a `Client` in order to
make use of connection pooling:

```python
import httpx
from httpx_sap_launchpad import URL_LAUNCHPAD, SAPLaunchpadAuth


def main() -> None:
    auth = SAPLaunchpadAuth(
        user_id='S1234567890',
        password='password',
    )
    with httpx.Client(auth=auth) as client:
        client.get(f'{URL_LAUNCHPAD}/applications/softwarecenter/version.json')


if __name__ == '__main__':
    main()
```

...or the `AsyncClient`:

```python
import asyncio

import httpx
from httpx_sap_launchpad import URL_LAUNCHPAD, SAPLaunchpadAuth


async def main() -> None:
    auth = SAPLaunchpadAuth(
        user_id='S1234567890',
        password='password',
    )
    async with httpx.AsyncClient(auth=auth) as client:
        await client.get(f'{URL_LAUNCHPAD}/applications/softwarecenter/version.json')


if __name__ == '__main__':
    asyncio.run(main())
```

## Credit

The authorization flow is based on the [community.sap_launchpad](https://github.com/sap-linuxlab/community.sap_launchpad) _Ansible_ collection.

## License

**MIT** - **wh!le (whilenot-dev)**, see [LICENSE](./LICENSE.txt)