semvec/pypi-packages huggingface dataset:
trainloop 0.4.0
Minimal PyTorch training loop with hooks and checkpointing.
Requires Python: >=3.10

# trainloop

[![PyPI version](https://img.shields.io/pypi/v/trainloop.svg)](https://pypi.org/project/trainloop/)

Minimal PyTorch training loop with hooks for logging, checkpointing, and customization.

Docs: https://karimknaebel.github.io/trainloop/

## Install

```bash
pip install trainloop
```

## Basic example

```python
import logging

import torch
import torch.nn as nn

from trainloop import BaseTrainer, CheckpointingHook, ProgressHook

logging.basicConfig(level=logging.INFO)


class MyTrainer(BaseTrainer):
    def build_data_loader(self):
        class ToyDataset(torch.utils.data.IterableDataset):
            def __iter__(self):
                while True:
                    data = torch.randn(784)
                    target = torch.randint(0, 10, (1,)).item()
                    yield data, target

        return torch.utils.data.DataLoader(ToyDataset(), batch_size=32)

    def build_model(self):
        return nn.Sequential(
            nn.Linear(784, 128),
            nn.ReLU(),
            nn.Linear(128, 10),
        ).to(self.device)

    def build_optimizer(self):
        return torch.optim.AdamW(self.model.parameters(), lr=3e-4)

    def build_hooks(self):
        return [
            ProgressHook(interval=50, with_records=True),
            CheckpointingHook(interval=500, keep_previous=2),
        ]

    def forward(self, batch):
        x, y = batch
        x, y = x.to(self.device), y.to(self.device)
        logits = self.model(x)
        loss = nn.functional.cross_entropy(logits, y)
        accuracy = (logits.argmax(1) == y).float().mean().item()
        return loss, {"accuracy": accuracy}


trainer = MyTrainer(max_steps=2000, device="cpu", workspace="runs/demo")
trainer.train()
```
mergify-cli 2026.2.19.1
Mergify CLI is a tool that automates the creation and management of stacked pull requests on GitHub
Requires Python: >=3.13

# Mergify CLI

## Introduction

Mergify CLI is a powerful tool designed to simplify and automate the creation
and management of stacked pull requests on GitHub as well as handling CI
results upload.

### Stacks

Before diving into its functionalities, let's grasp the concept of stacked pull
requests and why they matter in the
[documentation](https://docs.mergify.com/stacks/).

### CI

You can learn more about [CI Insights in the
documentation](https://docs.mergify.com/ci-insights/).

## Contributing

We welcome and appreciate contributions from the open-source community to make
this project better. Whether you're a developer, designer, tester, or just
someone with a good idea, we encourage you to get involved.
adaptera 0.1.2
A local-first LLM orchestration library
Requires Python: >=3.12
Keywords: llm, orchestration, local-first, ai, machine-learning

# Adaptera 🌌

A local-first LLM orchestration library with native support for Hugging Face, PEFT/LoRA, QLoRA — without hiding the model and giving advanced users the full control.

---
> **Note:** This project is in its early development phase and may undergo significant changes. However, the core goal of providing local LLM processing will remain consistent. Once the agentic part of the module is stable, we will work on making a fine-tuner for it so that this library can be used as a quick way of prototyping local agentic models.
> 
> Feel free to contribute, please do not spam pull requests. Any and all help is deeply appreciated.
---
## Features

- **Local-First**: Built for running LLMs on your own hardware efficiently.
- **Native PEFT/QLoRA**: Seamless integration with Hugging Face's PEFT for efficient model loading.
- **Persistent Memory**: Vector-based memory using FAISS with automatic text embedding (SLM).
- **Strict ReAct Agents**: Deterministic agent loops using JSON-based tool calls.
- **Model Transparency**: Easy access to the underlying Hugging Face model and tokenizer.

## Installation

### Using python
```bash
pip install adaptera
```

### Using Anaconda/Miniforge
```bash
conda activate < ENV NAME >
pip install adaptera
```

*(Note: Requires Python 3.12+)*

## Quick Start

```python
from adaptera import Agent, AdapteraModel, VectorDB, Tool

# 1. Initialize Vector Memory
db = VectorDB(index_file="memory.index")

# 2. Load a Model (with 4-bit quantization)
model = AdapteraModel(
    model_name="unsloth/Llama-3.2-3B-Instruct",
    quantization="4bit",
    vector_db=db
)

# 3. Define Tools
def add(a, b):
    """Adds two numbers together"""
    return a + b

tools = [
    Tool(name="add", func=add, description="Adds two numbers together. Input: 'a,b'")
]

# 4. Create and Run Agent
agent = Agent(model, tools=tools)
print(agent.run("What is 15 + 27?"))
```

## Project Structure

- `adaptera/chains/`: Agentic workflows and ReAct implementations.
- `adaptera/model/`: Hugging Face model loading and generation wrappers.
- `adaptera/memory/`: FAISS-backed persistent vector storage.
- `adaptera/tools/`: Tool registry and definition system.
- `adaptera/experimental/`: Experimental features 

## Non-goals

This library does not aim to be a full ML framework or replace existing tools like LangChain. It focuses on providing a clean, minimal interface for local-first LLM orchestration.
ynu-m-contest-client 0.1.1
Python client SDK for contest-server
Requires Python: >=3.9

# contest-client

Python SDK for the `contest-server`.

## Install (dev)
```bash
cd contest_client
python -m venv .venv
source .venv/bin/activate
pip install -U pip
pip install -e .
```

## Usage
サーバー側で用意されたコンテスト（`contest_id` は運営が `contest-provision --spec ...` 実行時の出力から取得し、必要な範囲で配布する想定）に対して、ユーザー登録・ログイン・提出を行うシナリオをサポートします。コンテスト作成や参加者(チーム)作成はクライアントからできません。
```python
from contest_client import ContestClient

c = ContestClient("http://127.0.0.1:8000")

# contest_id は運営から共有済み
contest_id = "cst_xxxxxx"

# 1) 初回登録
reg = c.register_user(contest_id, user_name="alice", password="secret123")
print("user_id:", reg["user_id"])
print("api_key (use for submissions):", reg["api_key"])

# 2) ログイン（APIキーをローテーションして取得）
login = c.login(contest_id, user_name="alice", password="secret123")
api_key = login["api_key"]

# 3) 提出
res = c.submit(contest_id, user_name="alice", api_key=api_key, x={"x1": 0.1, "x2": 0.7, "x3": 0.9})
print(res)

print(c.leaderboard(contest_id))
```
JoyPi-RGB-Matrix-RaspberryPi 1.0.0
This library enables usage of RGB matrix with RP2040 microcontroller chip on the Raspberry Pi.
Requires Python: >=3.9

# JoyPi_RGB_Matrix_RaspberryPi
This library enables usage of RGB matrix with RP2040 microcontroller chip on the Raspberry Pi.

>[!WARNING]
> This library was written for the usage of the LED matrix of the Joy-Pi Advanced 2 and Joy-Pi Note 2. Both Joy-Pis have the RP2040 microcontroller chip to control the LED matrix. This is to ensure compatibility with the Raspberry Pi 5 because the library which was used beforehand is not compatible up to this date.

## Installation
You can install this library from PyPI.
To install it for the current user on your Raspberry Pi, use the following command:
```
pip install JoyPi_RGB_Matrix_RaspberryPi
```

## Library Guide
- `LEDMatrix( count = 64, brightness = 10, right_border = [7,15,23,31,39,47,55,63], left_border = [0,8,16,24,32,40,48,56])`- initialize LED matrix with default values for Joy-Pi
- `clean()` - clears the LED matrix
- `setPixel(position, colour)` - sets specific pixel to a selected colour
- `RGB_on(colour)` - sets the complete matrix to one selected colour
- `RGB_off()` - turns the complete matrix off
- `rainbow(wait_ms=20, iterations=1)` - rainbow effect on the whole matrix with default values
- `colourWipe(colour, wait_ms=50)` - Move selected colour pixel by pixel onto the matrix with default speed
- `theaterChase( colour, wait_ms=50, iterations=10)` - chaser animation with a selected colour with deafult speed
- `show()` - displays set pixels
- `demo1()` - demo program version 1
- `demo2()` - demo program version 2