vc-runtime 0.1.0

Runtime backend for Visual Compiler
Documentation
use anyhow::{anyhow, Result};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::Instant;
use vc_shared::hashing::sha256;

use super::{ImageRenderer, RenderOutput, RenderParams, RendererKind, OUTPUT_FILENAME};

pub struct PythonRenderer {
    script_path: PathBuf,
    python_path: String,
}

impl PythonRenderer {
    pub fn new(script_path: &Path, python_path: Option<&str>) -> Self {
        Self {
            script_path: script_path.to_path_buf(),
            python_path: python_path.unwrap_or("python3").to_string(),
        }
    }

    fn run_python_script(
        &self,
        prompt: &str,
        negative_prompt: &str,
        seed: u64,
        output_path: &Path,
        params: &RenderParams,
    ) -> Result<()> {
        let script = self.script_path.to_str().ok_or_else(|| anyhow!("invalid script path"))?;
        let output = output_path.to_str().ok_or_else(|| anyhow!("invalid output path"))?;

        let mut cmd = Command::new(&self.python_path);
        cmd.arg(script)
            .arg("--prompt")
            .arg(prompt)
            .arg("--negative_prompt")
            .arg(negative_prompt)
            .arg("--seed")
            .arg(seed.to_string())
            .arg("--output")
            .arg(output)
            .arg("--width")
            .arg(params.width.to_string())
            .arg("--height")
            .arg(params.height.to_string())
            .arg("--steps")
            .arg(params.steps.to_string())
            .arg("--cfg")
            .arg(params.cfg.to_string());

        if !params.backend_options.is_null() {
            let opts_json = serde_json::to_string(&params.backend_options)?;
            cmd.arg("--backend_options").arg(opts_json);
        }

        let output = cmd.output()?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(anyhow!("Python script failed: {}", stderr));
        }

        Ok(())
    }
}

impl ImageRenderer for PythonRenderer {
    fn render(
        &self,
        prompt: &str,
        negative_prompt: &str,
        seed: u64,
        output_dir: &Path,
        params: &RenderParams,
    ) -> Result<RenderOutput> {
        let start = Instant::now();

        let image_path = output_dir.join(OUTPUT_FILENAME);

        self.run_python_script(prompt, negative_prompt, seed, &image_path, params)?;

        let image_bytes = std::fs::read(&image_path)?;
        let image_hash = sha256(&image_bytes);
        let duration_ms = start.elapsed().as_millis() as u64;

        Ok(RenderOutput {
            image_path,
            image_hash,
            duration_ms,
            backend: RendererKind::Python,
            seed,
        })
    }
}