semvec/pypi-packages huggingface dataset:
middleman-ml 0.1.1
Python SDK for Middleman GPU compute platform
Requires Python: >=3.8
Keywords: cloud, compute, gpu, machine-learning, ml, training

# Middleman ML SDK

Python SDK for the Middleman GPU compute platform.

## Installation

```bash
pip install middleman-ml
```

## Quick Start

```python
from middleman import MiddlemanClient

client = MiddlemanClient(api_key="mdlm_...")

# Create a training job
job = client.create_job(
    name="bert-training",
    gpu_type="a100",
    script="train.py",
    requirements=["torch", "transformers"]
)

# Monitor progress
client.wait_for_job(job.id)

# Check your balance
balance = client.get_balance()
print(f"Remaining credits: {balance.credits}")
```

## Features

- **Job Management**: Create, list, cancel, pause, resume jobs
- **Real-time Logs**: Stream training logs as they happen
- **File Uploads**: Upload datasets and scripts
- **Billing**: Check balance, view transactions
- **Webhooks**: Get notified on job status changes

## GPU Options

| GPU | Credits/hr | Best For |
|-----|------------|----------|
| T4 | 50 | Inference, small models |
| A100 | 350 | Large models, fast training |
| H100 | 600 | Maximum performance |

## Documentation

Full docs at [docs.middleman.run](https://docs.middleman.run)

## Support

- Email: support@middleman.run
- GitHub: [github.com/mkshepherd1/Middleman](https://github.com/mkshepherd1/Middleman)
ml-clara 1.5.0
Local LLM Inference Platform with adapter support and evaluation toolkit
Requires Python: <3.13,>=3.10
Keywords: llm, inference, lora, fine-tuning, mistral, transformers, cli, mps, apple-silicon

# ML-Clara

ML-Clara is a small, config-driven CLI + Python API for:

- Local LLM inference with streaming (`clara run`)
- Performance benchmarking (`clara bench`)
- Benchmark evaluation (`clara eval`)
- LoRA fine-tuning (`clara train`) and adapter merging (`clara export`)
- Device auto-detection (MPS/CUDA/CPU)

This repository also contains Apple’s **CLaRa** research codebase; ML-Clara lives in the `clara/` package.

---

## Install

```bash
pip install ml-clara
clara info
```

If your platform needs a specific PyTorch build, install PyTorch first, then install ML-Clara.

---

## Quickstart

### Run

```bash
clara run "Explain LoRA in one paragraph" --model gpt2
clara run "Write a haiku about debugging" --model gpt2 --stream
```

### Create a config (recommended)

```bash
clara init-config --type default -o config.yaml
clara run "Hello" --config config.yaml
```

### Eval

```bash
clara eval --model gpt2 --benchmarks perplexity --samples 50
```

### Bench (performance)

```bash
clara bench --model gpt2 --trials 3 --warmup 1
```

### Fine-tune (LoRA)

```bash
clara init-config --type finetune -o finetune.yaml
clara train --config finetune.yaml
```

### Web UI (FastAPI)

```bash
pip install "ml-clara[server]"
clara serve --model gpt2
```

Then open `http://127.0.0.1:8000`.

The server also exposes OpenAI-compatible endpoints (for Open WebUI/LangChain):
- `GET /v1/models`
- `POST /v1/chat/completions` (supports `stream: true` via SSE)

### GGUF / llama.cpp (inference-only)

Run `.gguf` models via llama.cpp using the optional GGUF backend:

```bash
pip install "ml-clara[gguf]"
clara run "Hello" --model /path/to/model.gguf --stream
clara serve --model /path/to/model.gguf
```

### Local checksum verification (optional)

Verify local model artifacts with SHA256 (useful for `.gguf` files and local model dirs):

```yaml
model:
  local_path: /path/to/model.gguf
  sha256: "0123... (64 hex chars)"
```

### Export (merge adapter)

```bash
clara export outputs/my-adapter/final --output models/merged
```

---

## Docs

- Troubleshooting: `docs/TROUBLESHOOTING.md`
- Benchmarking: `docs/BENCHMARKING.md`
- Full repository README (CLaRa research + ML-Clara section): `README.md`
digpipe 1.1.2
Decimal-Digit Input Pipeline
Requires Python: <4.0,>=3.10

# DigPipe

Modular Decimal-Digit Input Pipeline for GBA Emulation

[![CI](https://github.com/DJStompZone/digpipe/actions/workflows/ci.yml/badge.svg)](https://github.com/DJStompZone/digpipe/actions/workflows/ci.yml) [![CodeQL Advanced](https://github.com/DJStompZone/digpipe/actions/workflows/codeql.yml/badge.svg)](https://github.com/DJStompZone/digpipe/actions/workflows/codeql.yml) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/digpipe)

## Overview

**DigPipe** is a utility for decimal-digit generation, storage, mapping, and emulator-agnostic input rendering.

**\*Contextual note**: This is part of a larger project which aims to allow consecutive digits of pi to "play" video games. The gameplay will then be analyzed in an attempt to identify any emergent behaviors or patterns observed.\*

### High-Level Goal

Design and implement a **modular, chunk-based pipeline** that:

1. Generates **decimal digits (0–9)** from a mathematical source (initially π).
2. Stores digits efficiently in **chunked, compact binary form**.
3. Maps digits to **abstract input actions** (e.g., 10 GBA controls).
4. Emits emulator-agnostic or emulator-specific input streams (later).

This system is intended to scale to **hundreds of millions or billions of digits**, while remaining:

- memory-bounded
- resumable
- verifiable
- and emulator-agnostic.

## Agents

Coding agents and other automated tools should refer to [AGENTS.md](AGENTS.md) for complete project requirements and instructions
yumo 0.1.3
Scalar field visualization using Polyscope.
Requires Python: <4.0,>=3.10
Keywords: python

# yumo

[![Python Versions](https://img.shields.io/pypi/pyversions/yumo)](https://pypi.org/project/yumo/)
[![PyPI Version](https://img.shields.io/pypi/v/yumo)](https://pypi.org/project/yumo/)

Scalar field visualization using Polyscope.

- **Git repository**: <https://github.com/luocfprime/yumo/>


- **Documentation** <https://luocfprime.github.io/yumo/>

## Install

Prerequisites: You must have at least one Python package manager installed (e.g. [uv](https://docs.astral.sh/uv/getting-started/installation/)).

Install it from PyPI:

```bash
uv tool install yumo
```

Or, if you want to run it once without installing it, you can use the `uv run` command:

```bash
uv run --with yumo yumo xxx  # xxx being the subcommand you want to run
```

## Usage

```text
$ yumo -h

 Usage: yumo [OPTIONS] COMMAND [ARGS]...

╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --install-completion            Install completion for the current shell.                                                                       │
│ --show-completion               Show completion for the current shell, to copy it or customize the installation.                                │
│ --help                -h        Show this message and exit.                                                                                     │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ prune   Prune data points that are inside the mesh.                                                                                             │
│ viz     Visualize the scalar field.                                                                                                             │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) for details.

## License

MIT.
oEmbedPy 0.9.0
oEmbed client for Python.
Requires Python: >=3.9

========
oEmbedPy
========

Overview
========

This is `oEmbed <https://oembed.com>`_ client for Python.

Features
========

* Simple usage
* Python 3.x native
* Multiple endpoint discovery

Installation
============

This is uploaded on PyPI.

.. code-block:: console

   pip install oEmbedPy

Usage
=====

Library
-------

.. code-block:: pycon

    >>> from oembedpy.application import Oembed

    >>> oembed = Oembed()
    >>> oembed.init()
    >>> content = oembed.fetch("https://twitter.com/attakei")
    >>> print(content.type)
    rich

Commandline
-----------

.. note:: It needs Click for using CLI. Run extra install 'cli'.

Simple usage for author's video (omitted some output).

.. code-block:: console

   $ oEmbed.py 'https://www.youtube.com/watch?v=Oyh8nuaLASA'
   title:            Yoshi ( ...
   author_name:      attakei
   thumbnail_height: 360
   thumbnail_width:  400

If you want JSON, use ``--format`` option.

.. code-block:: console

   $ oEmbed.py --format=json 'https://www.youtube.com/watch?v=Oyh8nuaLASA'
   {"title":"Yoshi (NES - Nint ..."}

Others
------

This has extension for easy-using.
Please see `documentation <https://oEmbedPy.rtfd.io>`_.

License
=======

Apache License 2.0