biors 0.32.0

Command-line tools for bio-rs biological AI model input workflows.
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

use super::{workflow::workflow_output, PaddingArg};
use crate::errors::CliError;
use crate::output::print_success;
use biors_core::workflow::SequenceWorkflowOutput;
use serde::Serialize;
use std::path::PathBuf;

pub(crate) fn run_pipeline(
    max_length: usize,
    pad_token_id: u8,
    padding: PaddingArg,
    path: PathBuf,
) -> Result<(), CliError> {
    let output = workflow_output("biors pipeline", max_length, pad_token_id, padding, path)?;
    let pipeline = PipelineOutput::from_workflow(output);
    print_success(
        Some(pipeline.workflow.provenance.input_hash.clone()),
        pipeline,
    )
}

#[derive(Debug, Serialize)]
struct PipelineOutput {
    pipeline: &'static str,
    ready: bool,
    steps: Vec<PipelineStep>,
    workflow: SequenceWorkflowOutput,
}

#[derive(Debug, Serialize)]
struct PipelineStep {
    name: &'static str,
    status: &'static str,
    records: usize,
    warning_count: usize,
    error_count: usize,
    #[serde(skip_serializing_if = "Option::is_none")]
    output_sha256: Option<String>,
}

impl PipelineOutput {
    fn from_workflow(workflow: SequenceWorkflowOutput) -> Self {
        let validation = &workflow.validation;
        let tokenization = &workflow.tokenization.summary;
        let export_status = if workflow.model_ready {
            "passed"
        } else {
            "blocked"
        };
        Self {
            pipeline: "validate_tokenize_export.v0",
            ready: workflow.model_ready,
            steps: vec![
                PipelineStep {
                    name: "validate",
                    status: if validation.error_count == 0 {
                        "passed"
                    } else {
                        "failed"
                    },
                    records: validation.records,
                    warning_count: validation.warning_count,
                    error_count: validation.error_count,
                    output_sha256: None,
                },
                PipelineStep {
                    name: "tokenize",
                    status: if tokenization.error_count == 0 {
                        "passed"
                    } else {
                        "failed"
                    },
                    records: tokenization.records,
                    warning_count: tokenization.warning_count,
                    error_count: tokenization.error_count,
                    output_sha256: None,
                },
                PipelineStep {
                    name: "export",
                    status: export_status,
                    records: workflow
                        .model_input
                        .as_ref()
                        .map(|input| input.records.len())
                        .unwrap_or(0),
                    warning_count: 0,
                    error_count: if workflow.model_ready {
                        0
                    } else {
                        workflow.readiness_issues.len()
                    },
                    output_sha256: workflow
                        .model_ready
                        .then(|| workflow.provenance.hashes.output_data_sha256.clone()),
                },
            ],
            workflow,
        }
    }
}