semvec/pypi-packages huggingface dataset:
uio-api 0.1.1
UIO generic API wrappers with pluggable auth, retries, and pagination profiles
Requires Python: >=3.12

# UIO API

A Python library for interacting with UIO APIs, featuring built‑in authentication, robust retries, secure token storage, and pagination utilities.

## Documentation Map

- User Guide (usage, configuration, examples): `uio_api/README.md`
- Developer Guide (architecture, internals, patterns): `uio_api/INTERNAL.md`

## Features

- **🔐 Authentication**: Interactive login, static tokens, or system accounts
- **⚡ Retries**: Configurable retry strategy with exponential backoff
- **🛡️ Secure Storage**: Keyring or TOML‑based token storage
- **📄 Pagination**: DRF‑style pagination helpers and safeguards

## Installation

```bash
pip install uio-api
```

## Quick Start

```python
from uio_api import mreg_client
from uio_api.modules.mreg.endpoints import Endpoint

with mreg_client() as m:
    hosts = m.get_all(Endpoint.Hosts)
    print(f"Found {len(hosts)} hosts")
```

For full usage, configuration, and advanced examples, see `uio_api/README.md`.

## Token helpers

You can store credentials/tokens via the client instances (URLs resolved automatically):

```python
from uio_api import mreg_client, nivlheim_client

# MREG: add system user (uses MREG_URL from config)
with mreg_client() as client:
    client.add_system_user(username="svc", password="secret")

# MREG: add token with knobs (uses MREG_URL from config)
with mreg_client() as client:
    client.add_token(
        username="bob",
        token="abc123",
        scheme="Token",
        timeout=60.0,
        retry_attempts=5,
        page_size=1000,
    )

# Nivlheim: add API key (uses https://nivlheim.uio.no default)
with nivlheim_client() as client:
    client.add_token(
        username="svc",
        token="apikey123",
        scheme="APIKEY",
    )

# Or use explicit URLs
with mreg_client() as client:
    client.add_token(
        username="bob",
        token="abc123",
        url="https://custom.mreg.uio.no"
    )
```
lyceum-cli 1.0.4
Command-line interface for Lyceum Cloud Execution API
Requires Python: >=3.8
Keywords: cloud computing, code execution, docker, ai, inference, batch processing

# Lyceum CLI

Command-line interface for Lyceum Cloud Execution API - Execute code, run inference, and manage batch processing in the cloud.

## Features

- **Code Execution**: Run Python scripts and Docker containers on powerful cloud infrastructure
- **AI Inference**: Synchronous and batch inference with various AI models
- **Batch Processing**: OpenAI-compatible batch API for large-scale AI workloads
- **Resource Management**: List available machine types and monitor running jobs
- **S3 Storage**: Built-in file management with S3 backend

## Installation

```bash
pip install lyceum-cli
```

## Quick Start

1. **Login** with your API key:
```bash
lyceum login --api-key your-api-key-here
```

2. **Run Python code**:
```bash
lyceum run-python "print('Hello from the cloud!')"
```

3. **List available resources**:
```bash
lyceum machine-types
```

## Batch Processing

Upload and process large batches of AI requests:

```bash
# Upload a JSONL file
lyceum batch upload requests.jsonl

# Create batch job
lyceum batch create file_abc123 --endpoint /v1/chat/completions

# Monitor progress
lyceum batch get batch_xyz789

# Download results
lyceum batch download file_output123
```

## Command Structure

### Legacy Commands (for compatibility)
- `lyceum login` / `lyceum logout` / `lyceum status`
- `lyceum run-python` / `lyceum run-docker`
- `lyceum machine-types` / `lyceum list-jobs` / `lyceum abort`

### New Modular Commands
- `lyceum auth login` / `lyceum auth logout` / `lyceum auth status`
- `lyceum python run` / `lyceum docker run`
- `lyceum workloads list` / `lyceum workloads abort` / `lyceum workloads history`
- `lyceum batch upload` / `lyceum batch create` / `lyceum batch list`
- `lyceum resources machine-types`

## Configuration

Configuration is stored in `~/.lyceum/config.json`:

```json
{
  "api_key": "your-api-key",
  "base_url": "https://api.lyceum.technology"
}
```

## Support

- Documentation: https://docs.lyceum.technology
- Support: support@lyceum.technology
- Issues: https://github.com/lyceum/lyceum-cli/issues
raven-sdk 0.1.3
Async Kafka and HTTP producer SDK for Raven AI logs
Requires Python: >=3.8
Keywords: kafka, logging, ai, async, producer

# Raven SDK

Async Kafka and HTTP producer SDK for AI logs with support for both streaming and batch processing.

## Features

- **Kafka Producer**: Async Kafka producer for streaming AI logs
- **HTTP Producer**: Simple HTTP producer for batch AI log submissions
- **Pydantic Models**: Type-safe AI log models with automatic JSON serialization
- **UTC Timestamps**: Automatic UTC timestamp formatting with ISO-8601 standard

## Installation

```bash
pip install raven-sdk
```

## Quick Start

### Kafka Producer

```python
import asyncio
from datetime import datetime
from raven import AiLog, AiLogKafkaProducer

async def main():
    # Create producer
    producer = AiLogKafkaProducer("localhost:9092", topic="ai-logs")
    
    # Start producer
    await producer.start()
    
    try:
        # Create AI log
        log = AiLog(
            modelId="gpt-4",
            confidenceScore=0.95,
            responseTimeMs=150,
            timestamp=datetime.utcnow(),
            numericFeatures={"temperature": 0.7},
            categoricalFeatures={"type": "completion"}
        )
        
        # Send logs
        await producer.produce_ai_logs([log])
        
    finally:
        await producer.stop()

asyncio.run(main())
```

### HTTP Producer

```python
import asyncio
from datetime import datetime
from raven import AiLog, AiLogHttpProducer

async def main():
    # Create producer
    producer = AiLogHttpProducer("https://api.example.com/logs")
    
    # Create AI log
    log = AiLog(
        modelId="gpt-4",
        confidenceScore=0.95,
        responseTimeMs=150,
        timestamp=datetime.utcnow(),
        numericFeatures={"temperature": 0.7},
        categoricalFeatures={"type": "completion"}
    )
    
    # Send logs (no start/stop needed)
    await producer.produce_ai_logs([log])

asyncio.run(main())
```

## API Reference

### AiLog

Pydantic model representing an AI log entry.

**Fields:**
- `modelId: str` - Identifier for the AI model
- `confidenceScore: float` - Confidence score of the prediction
- `responseTimeMs: int` - Response time in milliseconds
- `timestamp: datetime` - UTC timestamp of the log
- `numericFeatures: Dict[str, float]` - Numeric features
- `categoricalFeatures: Dict[str, str]` - Categorical features

### AiLogKafkaProducer

Async Kafka producer for AI logs.

**Methods:**
- `__init__(kafka_bootstrap_servers: str, topic: str = "ai-logs")`
- `async start()` - Start the producer
- `async stop()` - Stop the producer
- `async produce_ai_logs(logs: List[AiLog])` - Send batch of logs
- `async produce_stream_logs(logs: AsyncIterable[AiLog])` - Send streaming logs

### AiLogHttpProducer

Simple HTTP producer for AI logs.

**Methods:**
- `__init__(endpoint_url: str, timeout: int = 30)`
- `async produce_ai_logs(logs: List[AiLog])` - Send batch of logs via POST

## Requirements

- Python 3.8+
- aiokafka>=0.8
- pydantic>=2.0
- aiohttp>=3.8

## License

MIT License
gif-pygame 1.2.0
A pygame addon for animated image files
Requires Python: >=3.7
Keywords: python, pygame, addon, image, animation, animated images

# gif_pygame

A pygame addon that allows you to load, animate, and render animated image files like .gif and .apng

## Basic Example Code

```py
import pygame
import gif_pygame
import sys

screen = pygame.display.set_mode((512, 512))
clock = pygame.Clock()

# Loading from a file. You can specify the number of loops, but by default it is infinite
animation_gif = gif_pygame.load("exmaple.gif")

# Creating an animation from a list of surfaces
s1 = pygame.Surface((20, 0))
s2 = pygame.Surface((20, 0))
s3 = pygame.Surface((20, 0))
s1.fill((255, 0, 0))
s2.fill((0, 255, 0))
s3.fill((0, 0, 255))

# For every list, first index must be the surface and second must be the duration in seconds. You can specify the number of loops, but by default it is infinite
animation_surfs = gif_pygame.GIFPygame([[s1, 1], [s2, 1], [s3, 0.5]])

# Main loop
while True:
    clock.tick(60)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

    screen.fill((0, 0, 0))

    # This module provides 2 methods for rendering the animation.

    # Method 1: using .render() | Animates and renders into the screen inside the function itself. You must pass down the surface to blit to and the location
    animation_gif.render(screen, (10, 10))

    # Method 2: using .blit_ready() | Animates the animation and returns the current frame. This was meant to be used alongside pygame.Surface().blit()
    screen.blit(animation_surfs.blit_ready(), (70, 70))

    pygame.display.flip()
```

To recap:

- `gif_pygame.load()`: Loads the animation file
- `gif_pygame.GIFPygame()`: Creates an animation from a list of surfaces and durations

To render the image you've got 2 options:
- `GIFPygame().render(surf, (x, y))`
- `surf.blit(GIFPygame().blit_ready(), (x, y))` (`.blit_ready()` can be used to return the current frame's surface)

There are also:
- `GIFPygame().pause()`: Pauses the animation
- `GIFPygame().unpause()`: Resumes the animation
- `GIFPygame().reset()`: Resets the animation's data
- `GIFPygame().copy()`: Returns a copy of the animation
- `GIFPygame().get_width()`: Returns the width of the animation
- `GIFPygame().get_height()`: Returns the height of the animation
- `GIFPygame().get_size()`: Returns the size of the animation
- `GIFPygame().get_rect()`: Returns the rect of the animation
- `GIFPygame().get_surfaces()`: Returns a list of all surfaces in the animation, you can also pass in certain indexes
- `GIFPygame().get_durations()`: Returns a list of all durations in the animation, you can also pass in certain indexes
- `GIFPygame().get_frame_data()`: Returns a list of all surfaces and durations in the animation, you can also pass in certain indexes

The module also contains a sublibrary for editing the animation, `gif_pygame.transform`, which has almost all of the transform options pygame gives, and allows for editing the animation's frame data

Please use python's `help()` function for more in-depth explanation

*(A documentation will be added soon)*