pixforge 0.3.1

Fast CLI to generate images via OpenAI, Azure, Gemini, LocalAI, and other image-gen providers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Live integration test against a LocalAI server (free, runs locally).
//!
//! This test is `#[ignore]` by default so `cargo test` doesn't require
//! Docker to be running. To run it:
//!
//! 1. Start LocalAI (CPU-only image, ~3 GB):
//!    ```sh
//!    docker run --rm -p 8080:8080 --name pixforge-localai localai/localai:latest
//!    ```
//!
//! 2. Install a small image model (one-time, ~5 minutes):
//!    ```sh
//!    curl http://localhost:8080/models/apply \
//!      -H 'Content-Type: application/json' \
//!      -d '{"id":"huggingface@stable-diffusion-1.5"}'
//!    ```
//!
//! 3. Wait for the model to finish downloading, then run:
//!    ```sh
//!    PIXFORGE_LOCALAI_URL=http://localhost:8080/v1 \
//!    PIXFORGE_LOCALAI_MODEL=stable-diffusion-1.5 \
//!      cargo test --test localai_integration -- --ignored --nocapture
//!    ```
//!
//! If `PIXFORGE_LOCALAI_URL` is unset, the test self-skips with a clear
//! message instead of failing.

use pixforge::providers::openai_compat::{AuthStyle, OpenaiCompatProvider};
use pixforge::providers::{ImageProvider, Request, Size};

#[test]
#[ignore = "requires a running LocalAI server; see file docs"]
fn localai_generates_a_real_image() {
    let Some(url) = std::env::var("PIXFORGE_LOCALAI_URL").ok() else {
        eprintln!(
            "PIXFORGE_LOCALAI_URL not set; skipping. \
             See tests/localai_integration.rs for setup."
        );
        return;
    };
    let model = std::env::var("PIXFORGE_LOCALAI_MODEL")
        .unwrap_or_else(|_| "stable-diffusion-1.5".to_string());

    let p = OpenaiCompatProvider {
        endpoint: url,
        api_key: None,
        auth_style: AuthStyle::None,
        // LocalAI on CPU is slow — generation can take 60–120s per image.
        timeout_secs: 240,
        max_attempts: 1,
    };

    let extra = serde_json::Map::new();
    let req = Request {
        prompt: "a tiny pixel-art forest, low detail",
        model: &model,
        n: 1,
        size: Some(Size {
            width: 256,
            height: 256,
        }),
        size_explicit: true,
        seed: None,
        negative_prompt: None,
        quality: None,
        extra: &extra,
    };

    let mut on_retry = |a: u32, m: &str, w: f64| {
        eprintln!("retry attempt {a}: {m} (sleep {w:.1}s)");
    };

    let result = p
        .generate(&req, &mut on_retry)
        .expect("LocalAI generation failed; is the model installed?");

    assert!(!result.images.is_empty(), "no images returned");
    let img = &result.images[0];
    assert!(
        !img.bytes.is_empty(),
        "image bytes are empty (got mime={})",
        img.mime_type
    );
    // Sanity-check the magic number — should be a PNG or JPEG.
    let header = &img.bytes[..img.bytes.len().min(8)];
    assert!(
        header.starts_with(b"\x89PNG") || header.starts_with(b"\xff\xd8"),
        "image bytes don't look like PNG or JPEG; got header {:?}",
        header
    );

    eprintln!(
        "LocalAI generated {} bytes ({}) in {:.1}s",
        img.bytes.len(),
        img.mime_type,
        result.latency_secs
    );
}