Metadata-Version: 2.4
Name: fleethq
Version: 0.2.0
Summary: Train, evaluate, and deploy AI models on Fleet without managing infrastructure
Project-URL: Homepage, https://fleethq.dev
Project-URL: Documentation, https://fleethq.dev/docs
Project-URL: Repository, https://github.com/jlognn/fleet
License: MIT
Keywords: ai,fine-tuning,gpu,llm,machine-learning
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.11
Requires-Dist: httpx>=0.27
Requires-Dist: rich>=13.0
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == 'dev'
Description-Content-Type: text/markdown

# Fleet SDK

Train, evaluate, and deploy AI models on cloud GPUs from your local machine.

## Installation

```bash
pip install fleethq
```

## Authentication

```bash
fleet login
```

This opens a browser to authenticate. Your credentials are saved to `~/.fleet/credentials`.

## Quickstart

```python
import fleet

client = fleet.Fleet()

# Load a model, train it, deploy it
model = client.load("./my-model")
job = model.train(dataset="./data.jsonl")
job.wait()
endpoint = model.deploy()
result = endpoint.infer("Hello, world!")
```

## Loading Models

### From a local directory

If you have model weights locally (safetensors, .bin, .pt, etc.):

```python
model = client.load("./path/to/model", name="my-model")
```

### From HuggingFace

Download the model locally first, then load into Fleet:

```python
from huggingface_hub import snapshot_download

path = snapshot_download("Qwen/Qwen2.5-7B")
model = client.load(path, name="qwen2.5-7b")
```

Fleet uploads the weights to its model registry. Subsequent pushes of the same model are instant — Fleet deduplicates by content hash.

### Fine-tuned models

After training, the output model is automatically registered and can be deployed or used as a base for further fine-tuning:

```python
job = model.train(dataset="./data.jsonl")
job.wait()
fine_tuned = job.model()   # the output model
endpoint = fine_tuned.deploy()
```

## Training

```python
job = model.train(
    dataset="./data.jsonl",      # local path or R2 key
    hardware="fleet:economy",    # GPU tier (default: fleet:economy)
    method="lora",               # full, lora, qlora (default: full)
)

# Stream logs
for line in job.logs():
    print(line)

# Or just wait
job.wait()
print(job.status)
```

### Hardware tiers

| Tier | GPU | Use case |
|------|-----|----------|
| `fleet:cpu` | CPU only | Testing |
| `fleet:micro` | T4 16GB | Small models |
| `fleet:economy` | L4 24GB | Mid-size models |
| `fleet:standard` | A10G 24GB | Default |
| `fleet:pro` | A100 40GB | Large models |
| `fleet:ultra` | H100 80GB | Maximum |

## Inference

```python
endpoint = model.deploy(hardware="fleet:standard")

result = endpoint.infer("What is the capital of France?")
print(result)
```

## CLI

```bash
fleet login                          # authenticate
fleet whoami                         # show current user
fleet models                         # list models
fleet jobs                           # list recent jobs
fleet jobs logs <job_id>             # stream job logs
fleet deployments                    # list deployments
fleet deploy <model_id> [hardware]   # deploy a model
fleet infer <deployment_id> <prompt> # run inference
```
