biors 0.56.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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::fs;

mod common;

#[test]
fn service_interface_docs_list_request_response_examples() {
    let repo = common::repo_root();
    let service_doc =
        fs::read_to_string(repo.join("docs/service-interface.md")).expect("read service docs");

    for expected in [
        "Request And Response Schemas",
        "Local HTTP Mode",
        "biors serve",
        "GET /health",
        "GET /openapi.json",
        "POST /v0/batch/sequence/validate",
        "sequence.validate",
        "sequence.batch_validate",
        "sequence.inspect",
        "sequence.tokenize",
        "model_input.build",
        "package.inspect",
        "package.validate",
        "package.bridge.plan",
        "package.compatibility.compare",
        "fasta-validation-output.v0.json",
        "service-batch-sequence-validate-output.v0.json",
        "model-input-output.v0.json",
        "package-compatibility-output.v0.json",
    ] {
        assert!(
            service_doc.contains(expected),
            "service interface docs missing request/response example detail: {expected}"
        );
    }
}

#[test]
fn sequence_kind_support_matrix_covers_promoted_surfaces() {
    let repo = common::repo_root();
    let matrix =
        fs::read_to_string(repo.join("docs/sequence-kind-support.md")).expect("read matrix");
    let readme = fs::read_to_string(repo.join("README.md")).expect("read README");
    let service_tokenize_schema =
        fs::read_to_string(repo.join("schemas/service-sequence-tokenize-request.v0.json"))
            .expect("read service tokenize schema");
    let service_model_input_schema =
        fs::read_to_string(repo.join("schemas/service-model-input-request.v0.json"))
            .expect("read service model-input schema");
    let pipeline_config_schema = fs::read_to_string(repo.join("schemas/pipeline-config.v0.json"))
        .expect("read pipeline config schema");
    let python_api = fs::read_to_string(repo.join("docs/python-api.md")).expect("read Python API");
    let python_stub =
        fs::read_to_string(repo.join("crates/biors-python/python/biors/__init__.pyi"))
            .expect("read Python stub");

    assert!(
        readme.contains("docs/sequence-kind-support.md"),
        "README must link the sequence-kind support matrix before broad DNA/RNA claims"
    );

    for expected in [
        "CLI `fasta validate` / `seq validate`",
        "CLI `batch validate`",
        "CLI `tokenize`",
        "CLI `model-input`",
        "CLI `workflow`",
        "CLI `pipeline --config`",
        "Python bindings",
        "WASM / JavaScript bindings",
        "MCP server",
        "Service contract schemas",
        "Package manifest validation",
        "Package conversion from Python/HF projects",
        "Benchmarks",
        "project-conversion limitations",
        "validate_fasta_input_with_kind",
    ] {
        assert!(
            matrix.contains(expected),
            "support matrix missing promoted surface or limitation: {expected}"
        );
    }

    for profile in [
        "protein-20",
        "protein-20-special",
        "dna-iupac",
        "dna-iupac-special",
        "rna-iupac",
        "rna-iupac-special",
    ] {
        assert!(
            matrix.contains(profile),
            "support matrix missing tokenizer profile: {profile}"
        );
        assert!(
            service_tokenize_schema.contains(profile),
            "service tokenize schema missing tokenizer profile: {profile}"
        );
        assert!(
            service_model_input_schema.contains(profile),
            "service model-input schema missing tokenizer profile: {profile}"
        );
        assert!(
            pipeline_config_schema.contains(profile),
            "pipeline config schema missing tokenizer profile: {profile}"
        );
    }

    for kind in ["protein", "dna", "rna"] {
        assert!(
            pipeline_config_schema.contains(kind),
            "pipeline config schema missing sequence kind: {kind}"
        );
    }

    for surface in [python_api.as_str(), python_stub.as_str()] {
        assert!(
            surface.contains("validate_fasta_input_with_kind"),
            "Python kind-aware validation helper must be documented and typed"
        );
    }
}