semvec/pypi-packages huggingface dataset:
hf-s3-mirror 0.4.1
CLI tool for uploading HuggingFace models to S3 storage
Requires Python: >=3.10
Keywords: cli, huggingface, mirror, models, s3

# hf-s3-mirror

CLI tool for mirroring HuggingFace models to S3-compatible storage.

## Installation

```bash
pip install hf-s3-mirror
```

## Configuration

Create `.env` file in your working directory:

```bash
S3_ACCESS_KEY=your_access_key
S3_SECRET_KEY=your_secret_key
S3_ENDPOINT_URL=http://your-s3-endpoint
S3_REGION=ru-1
S3_BUCKET=model-bucket
S3_USE_SSL=false
```

Or export environment variables:

```bash
export S3_ACCESS_KEY=your_access_key
export S3_SECRET_KEY=your_secret_key
export S3_ENDPOINT_URL=http://your-s3-endpoint
export S3_REGION=ru-1
export S3_BUCKET=model-bucket
```

## Usage

### Upload model from HuggingFace to S3

```bash
# Basic usage
hf-s3 upload openai/whisper-large-v3

# With custom bucket and prefix
hf-s3 upload lab-ii/whisper-large-v3 -b my-bucket -p models/
```

### Upload local directory to S3

```bash
hf-s3 upload-local ./my-model -b model-bucket -p models/
```

### Download model from S3 mirror

```bash
hf-s3 download lab-ii/whisper-large-v3 -o ./models
```

### List bucket contents

```bash
# List root
hf-s3 list-bucket

# List specific path
hf-s3 list-bucket -p models--lab-ii--whisper-large-v3
```

### Delete model from S3

```bash
# By repo_id (will ask for confirmation)
hf-s3 delete lab-ii/whisper-large-v3

# By direct path
hf-s3 delete models--lab-ii--whisper-large-v3

# Skip confirmation (for scripts)
hf-s3 delete lab-ii/bad-model --force
```

## Commands Reference

| Command | Description |
|---------|-------------|
| `upload <repo_id>` | Download from HuggingFace and upload to S3 |
| `upload-local <path>` | Upload local directory to S3 |
| `download <repo_id>` | Download from S3 mirror to local |
| `list-bucket` | List S3 bucket contents |
| `delete <path>` | Delete folder from S3 (with confirmation) |

## Common Options

| Option | Short | Description |
|--------|-------|-------------|
| `--bucket` | `-b` | S3 bucket name (overrides env) |
| `--prefix` | `-p` | S3 prefix path |
| `--help` | | Show command help |

## S3 Storage Structure

Models are stored with the following naming convention:

```
bucket/
  models--organization--model-name/
    config.json
    model.bin
    tokenizer.json
    ...
```

## License

Apache 2.0
pattern-agentic-settings 2.0.0
Pydantic-powered config management
Requires Python: >=3.11


# Pattern Agentic Settings

A settings class based on pydantic-settings that facilitates:

  - printing all settings on startup (redacts senstive attrs)
  - easy loading of .env files via an env variable
  - optionally load app version from importlib (sourced from pyproject.toml)
  - optional hot reload using watchfiles


## Installation

    pip install pattern_agentic_settings[hotreload]

Note that without the hotreload extension:

    pip install pattern_agentic_settings

watchfiles is not pulled in, and dot envs will not auto-reload. 


## Example

```python
class Settings(PABaseSettings):
    model_config = SettingsConfigDict(
        env_prefix="MYAPP_"
    )
    worker_count: int

# expects MYAPP_WORKER_COUNT 
# if MYAPP_DOT_ENV points to a file, will try to load vars from it
# throws an error if not defined
settings = Settings.load('my_app')

# This will watch the env file on disk and reload values if it changes
# This must be called in the context of an existing async runloop
# it also requires the hotreload extension (see Installation)

settings.watch_env_file()
```

Exepcted output:

```
My App v1.0.0
Configuration:
  WORKER_COUNT: 3
```

And on failure:

```
RuntimeError: Configuration validation failed:

      Missing required configuration fields:
        - worker_count
```


## Tests

To run the tests the package must be installed in edit mode:

    uv pip install -e .
    
    # or to test hotreload
    uv pip install -e .[hotreload]

After that:

    # Base test
    uv run pytest tests/test_base.py

    # All tests
    uv run pytest
sales-pipeline 0.1.7
Pipeline de traitement Spark Bronze / Silver / Gold
Requires Python: >=3.8

# Sales Pipeline - Databricks

## But du projet
Pipeline de traitement des ventes en **3 couches** :
- **Bronze** : ingestion des CSV bruts depuis DBFS.
- **Silver** : nettoyage et harmonisation des données.
- **Gold** : agrégations et calculs pour analyse (CA, classement produits).

## Lancement

### Pipeline complet
Le fichier `main.py` permet de lancer le pipeline entier.

### Tests
Le fichier `launch_tests.ipynb` permet de lancer les tests.
fewsxml 0.2.0
A library for reading and writing XML files to interact with Delft-FEWS.
Requires Python: >=3.11

# fewsxml

## Table of Contents

- [Installation](#installation)
- [Overview](#overview)
- [Usage Example](#usage-example)
  - [Creating a PI-XML File and Writing to Disk](#creating-a-pi-xml-file-and-writing-to-disk)
  - [Reading a PI-XML File and Creating Pydantic Models](#reading-a-pi-xml-file-and-creating-pydantic-models)
- [API Reference](#api-reference)
- [Schema Compatibility](#schema-compatibility)

## Installation
```commandline
pip install fewsxml
```

## Overview

fewsxml provides Python APIs to construct, read, and write PI-XML files 
compatible with the Delft-FEWS system. It uses Pydantic models for data 
validation and supports the PI TimeSeries schema.

There are two main categories of functions:
1. **Creating PI-XML Files**: Functions to create PIHeader, PISeries, and PITimeSeries objects, and to write them to XML files.
2. **Reading PI-XML Files**: Functions to read and parse existing PI-XML files into Pydantic models.

## Usage Example

### Creating a PI-XML File and Writing to Disk

Below is a minimal example to create a PI-XML file with a time series, including all required header fields such as `timeStep` and `missVal`:

```python
from fewsxml import (
    create_pi_header, create_pi_series, create_pi_timeseries, write,
    PITimeStep
)
from datetime import datetime

time_step = PITimeStep(unit="second", multiplier=3600)

# Create the header with all required fields
header = create_pi_header(
    type="instantaneous",
    location_id="LOC001",
    parameter_id="H.waterlevel",
    start_date=datetime(2023, 1, 1, 0, 0),
    end_date=datetime(2023, 1, 1, 2, 0),
    timeStep=time_step,
    missVal="-999"
)

# Create events (time series values)
events = [
    {"date": datetime(2023, 1, 1, 0, 0), "value": 1.23},
    {"date": datetime(2023, 1, 1, 1, 0), "value": 1.25},
    {"date": datetime(2023, 1, 1, 2, 0), "value": 1.20},
]

# Build the series and root object
series = create_pi_series(header, events)
pi = create_pi_timeseries(series)

# Write to XML file
write(pi, "output.xml")
```

### Reading a PI-XML File and Creating Pydantic Models

```python
import fewsxml as fx
parsed_timeseries = fx.read("timeseries_import.xml")
```

The `parsed_timeseries` variable now contains a `PITimeSeries` object 
with all data from the XML file, accessible via Pydantic models. As mentioned in the previous example, you can create an XML file 
from these models using the `write` function: `fx.write(parsed_timeseries, "output.xml")`. 
The created XML file will be compatible with the PI TimeSeries schema.

## API Reference

- `create_pi_header(...)`: Creates a PIHeader object (series metadata).
- `create_pi_series(header, events, ...)`: Creates a PISeries object from a header and events.
- `create_pi_timeseries(series, ...)`: Creates the root PITimeSeries object.
- `write(pi, filename)`: Writes a PITimeSeries object to an XML file.

## Schema Compatibility

The generated XML files are compatible with the [PI TimeSeries schema](https://fewsdocs.deltares.nl/schemas/version1.0/pi-schemas/pi_timeseries.xsd).
spay 3.0.0
Python SDK for Spay internet gateway
Requires Python: >=3.8

# spay

**SPAY Python SDK** for integrating the **SPAY Internet Payment Gateway (IPG)** into Python applications.

This SDK provides a simple, structured interface to handle the full SPAY payment lifecycle:

- Token generation
- Payment request
- Transaction verification

It is designed for backend services such as **Django**, **FastAPI**, **Flask**, or any Python-based system.

---

## Installation

Install the SDK using `pip`:

```bash
pip install spay
```

## Usage
1. Create a Client Instance
    First, instantiate the SpayClient class.

    Required parameters:
    merchant_id (str)
    amount (int)

    Optional parameters:
    callback_url (str)
    mobile (str)
    email (str)
    description (str)


from spay import SpayClient

client = SpayClient(
    merchant_id="YOUR_MERCHANT_ID",
    amount=500000,
    callback_url="https://example.com/callback",
    mobile="09123456789",
    email="user@example.com",
    description="Order payment"
)

2. Get Payment Token
    Generate a payment token using the get_token method:

    token = client.get_token()

3. Request Payment

    Use the generated token to request payment and receive the IPG URL:
    ipg_url = client.request_payment()


4. Verify Payment

    After the payment process, SPay redirects the user to your callback_url.
    Verify the transaction using the verify_payment method:
    result = client.verify_payment(token)
traj-render 0.1.0
A high-performance OpenGL-based trajectory renderer
Requires Python: >=3.8

# Trajectory Renderer (traj-render)

A high-performance OpenGL-based trajectory renderer using ModernGL. Supports 15+ gradient modes, glow effects, and multi-threaded rendering.

## Installation

```bash
pip install traj-render
```

## Quick Start

```python
import numpy as np
from traj_render import EnhancedTrajectoryRenderer, TrajectoryStyle, GradientMode

# Initialize renderer
renderer = EnhancedTrajectoryRenderer(frame_size=(1920, 1080))

# Define trajectory style
style = TrajectoryStyle(
    head_width=20.0,
    tail_width=2.0,
    max_length=50,
    gradient_mode=GradientMode.AURORA,
    glow_enabled=True
)

# Example points
points = np.array([[100, 100], [200, 300], [400, 200]], dtype=np.float32)

# Render frame
# Note: You'll need an OpenGL context or use the built-in standalone context
# frame = renderer.render_frame(points, style)
```

## Features
- 15+ Gradient Modes (Aurora, Cyberpunk, Fire, etc.)
- Gaussian Blur Glow Effects
- High-performance ModernGL implementation
- Standalone OpenGL context support