semvec/pypi-packages huggingface dataset:
limitless-ai 0.1.0
Universal AI Game Agent
License: MIT
Requires Python: >=3.10

# Limitless: Universal AI Game Agent

Limitless is a high-performance, vision-only foundation model agent designed to learn and play any commercial video game. It uses a ResNet50 backbone to map raw gameplay pixels directly to virtual controller actions.

##  Features

- **Universal Simulator**: A Gymnasium-compatible environment that captures any game window and sends inputs via a Virtual Xbox 360 Controller.
- **Vision-Only Generalist**: No game-specific IDs or embeddings. The model learns pure visual-to-action mapping, allowing for zero-shot potential across different games.
- **Robust Extractor**: Automatically extracts controller states from gameplay videos, even with semi-transparent overlays (e.g., Cuphead, Ready or Not).

## 🛠️ Installation

### 1. Prerequisites
- **Python 3.10+**
- **ViGEmBus Driver**: Required for virtual controller support. [Download here](https://github.com/ViGEm/ViGEmBus/releases).
- **NVIDIA GPU**: Recommended for high-speed training and inference.

### 2. Setup
```powershell
# Clone the repository
git clone https://github.com/haumlab/limitless
cd limitless

# Install the package
pip install .
```

##  Usage

Once installed, you can use the `limitless` command directly.

### 1. Extract Data
Extract actions from your own gameplay videos.
```powershell
limitless extract --input "path/to/videos" --output "dataset/my_game"
```

### 2. Train the Model
Train the "Limitless" model on one or multiple datasets.
```powershell
limitless train --dataset dataset/readyornot --dataset dataset/cuphead
```

### 3. Run the Agent
Run the trained agent on a live game window.
```powershell
limitless run --window "Cuphead" --model limitless_latest.pth
```

### 4. Test on Video
Visualize the model's predictions on a video file before running it live.
```powershell
limitless test-video --video "gameplay.mp4" --model limitless_latest.pth
```

##  Technical Architecture

- **Backbone**: ResNet50 (Pre-trained on ImageNet).
- **Policy Heads**: 
  - **Buttons**: Multi-label classification (Sigmoid + BCEWithLogitsLoss).
  - **Sticks**: Regression (MSELoss) for LX, LY, RX, RY axes.
- **Input**: 224x224 RGB frames.
- **Output**: 14 Buttons, 4 Stick Axes.

##  Safety & Isolation
Limitless is designed to be non-intrusive:
- It uses a **Virtual Gamepad** (vgamepad) and does not touch your physical mouse or keyboard.
- It captures screen data via `mss` and does not inject code into game processes.

##  License
MIT
paperfig 0.2.0
JSON-driven orchestration for building and concatenating paper figures.
License: MIT
Requires Python: >=3.9

# paperfig: JSON‑driven figure orchestrator
`paperfig` is a small library for building per-figure PDFs from a JSON spec and combining them into a single figures.pdf. The JSON file can mix data and rendering functions, so you can flexibly compose plots and layouts. This makes it handy for generating figures for papers. You provide the renderers (Python functions that draw and save fig{index}.pdf), while paperfig takes care of JSON parsing, dispatching, multi-panel layouts, and concatenation.

## Key features
- Simple JSON spec → figures
- Use your own renderers; paperfig only orchestrates
- Supports both simple figures and multi‑panel grids
- Concatenates everything into a single figures.pdf
- Extensible: register functions, import "module:function", or use entry points

## Install
- Library only: `pip install paperfig`
- With example dependencies: `pip install "paperfig[examples]"`
## Quick start (run the bundled example)
- Clone the source repository
```bash
git clone https://github.com/sekika/paperfig.git
```
- Change into the examples directory and run the script:
```bash
cd paperfig/docs/examples
python fig.py
```
- Outputs:
  - docs/examples/fig/fig1.pdf, fig2.pdf, fig3a.pdf … fig3d.pdf
  - docs/examples/fig/fig3.pdf (2x2 multi panel)
  - docs/examples/fig/figures.pdf (all pages concatenated)

## CLI
- Build: `paperfig build path/to/fig.json -d out -o figures.pdf`
- Validate only: `paperfig validate path/to/fig.json`
- List figures: `paperfig list path/to/fig.json`

## Minimal API example
- Define a renderer that writes fig{index}.pdf into fig_dir. Register and build.

```python
from paperfig.figure import Fig
import matplotlib.pyplot as plt

def render_hello(index, data, verbose=1):
    fig, ax = plt.subplots()
    ax.text(0.5, 0.5, f"Hello {index}", ha="center", va="center")
    plt.savefig(f"out/fig{index}.pdf"); plt.close(fig)

fig = Fig("fig.json")
fig.fig_dir = "out"
fig.function = {"hello": render_hello}
fig.create_pdf()
```

JSON spec example (with multi)
```json
{
  "1": { "type": "hello" },
  "2": { "type": "hello" },
  "3": {
    "type": "multi",
    "row": 1,
    "column": 2,
    "figures": {
      "3a": { "type": "hello" },
      "3b": { "type": "hello" }
    }
  }
}
```

## Extensibility
- Register a renderer in code: fig.function["name"] = callable
- Refer to a renderer by string: "module:function" in JSON type
- Plugin system: packages can expose entry points under paperfig.renderers

## Documentation
- See [https://sekika.github.io/paperfig/](https://sekika.github.io/paperfig/) for the full guide.

## License
- MIT License
goodbye-bro 0.1.2
A tiny Python library that says Goodbye, World!
License: MIT
Requires Python: >=3.8

### 0. Hello!

Ho ho ho! A minimal Python library that prints a friendly goodbye message.

### 1. Installation

```bash
pip install goodbye-bro
```

### 2. Usage

```python
import goodbye
goodbye.say()
```

## 3. Output

Goodbye, World!

### 4. Why this exists

- Clean example package
- Zero dependencies
- Beginner friendly
- ASCII safe
- No magic, no noise

### 5. Goodbye!

Goodbye!

### 6. License

MIT License

Made by bro