saccade 0.2.9

Visual-regression CLI for renderers and graphics code, built on NVIDIA FLIP
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Explicit dataset split and photo burst candidate review.
use crate::{agent::CliError, general_cmd};
use saccade_core::general::{input, split_review};
use std::path::PathBuf;
#[derive(clap::Args)]
pub(crate) struct Args {
    /// saccade-split-manifest.v1; paths resolve relative to this file.
    manifest: PathBuf,
    /// Inclusive perceptual-hash distance, 0..64.
    #[arg(long, default_value = "6")]
    hash_threshold: u32,
    /// Explicitly enable a provisioned embedding route; never downloads.
    #[arg(long)]
    embeddings: bool,
    /// Inclusive raw cosine candidate threshold.
    #[arg(long, default_value = "0.95")]
    cosine_threshold: f64,
    /// New or empty output directory outside the dataset.
    #[arg(long, default_value = "split-review-report")]
    out: PathBuf,
    /// Emit the complete versioned review, including limitations.
    #[arg(long)]
    json: bool,
}
pub(crate) fn run(args: Args) -> Result<u8, CliError> {
    let manifest: split_review::Manifest =
        serde_json::from_slice(&input::bytes(&args.manifest, 1024 * 1024)?)?;
    let root = args
        .manifest
        .parent()
        .filter(|p| !p.as_os_str().is_empty())
        .unwrap_or(std::path::Path::new("."));
    let paths = manifest.resolve(root)?;
    let mut inputs: Vec<_> = paths.iter().map(PathBuf::as_path).collect();
    inputs.push(root);
    general_cmd::prepare_out(&args.out, &inputs)?;
    let report = if args.embeddings {
        #[cfg(feature = "embeddings")]
        {
            let cfg = crate::wave7_cmd::config()?;
            let contract = cfg.embedding_contract.as_ref().ok_or_else(|| {
                CliError::usage(
                    "embedding contract not configured; provision with models pull embedding",
                )
            })?;
            let library = cfg
                .runtime_library
                .as_ref()
                .ok_or_else(|| CliError::usage("ONNX runtime library not configured"))?;
            let model = saccade_core::general::embedding::parse_model(&input::bytes(
                contract,
                2 * 1024 * 1024,
            )?)?;
            let identity = saccade_core::localized::digest(&serde_json::to_vec(&model)?);
            let engine =
                saccade_core::general::embedding::Engine::load(model, &cfg.dir, library, false)?;
            let mut route = Route { engine, identity };
            split_review::review(
                &manifest,
                root,
                args.hash_threshold,
                args.cosine_threshold,
                Some(&mut route),
            )?
        }
        #[cfg(not(feature = "embeddings"))]
        {
            return Err(CliError::new(
                "feature_unavailable",
                "split-review --embeddings requires the embeddings feature and a provisioned model",
            ));
        }
    } else {
        split_review::review(
            &manifest,
            root,
            args.hash_threshold,
            args.cosine_threshold,
            None,
        )?
    };
    let file = general_cmd::persist_document(&report, &args.out)?;
    std::fs::write(args.out.join("pairs.csv"), split_review::csv(&report)?)
        .map_err(|e| CliError::io(e.to_string()))?;
    if args.json {
        crate::emit(&format!(
            "{}\n",
            saccade_core::report_links::decorate(&report)?
        ))?;
    } else {
        crate::emit(&format!(
            "{}\nRoutes: hash, geometric; embedding {}. Read limitations in {}.\n",
            report["summary"].as_str().unwrap_or("Review complete"),
            if args.embeddings {
                "used"
            } else {
                "not enabled"
            },
            file.display()
        ))?;
    }
    Ok(u8::from(report["verdict"] == "review_required"))
}
#[cfg(feature = "embeddings")]
struct Route {
    engine: saccade_core::general::embedding::Engine,
    identity: String,
}
#[cfg(feature = "embeddings")]
impl split_review::EmbeddingRoute for Route {
    fn identity(&self) -> &str {
        &self.identity
    }
    fn embed(&mut self, image: &image::RgbaImage) -> saccade_core::Result<Vec<f32>> {
        self.engine.embed(image)
    }
}