Struct Artifacts 

pub struct Artifacts {
    pub schema: u32,
    pub producer: String,
    pub created: String,
    pub categories: Vec<CategoryRecord>,
    pub gazetteer: Vec<Registration>,
    pub relations: Vec<String>,
    pub motifs: Vec<CategoryRecord>,
    pub digests: BTreeMap<String, usize>,
    pub training_examples: usize,
    pub contains_document_text: Vec<String>,
    /* private fields */
}

The complete set. Small, human-readable, and diffable on purpose — a vocabulary change should show up in review like any other change.

Fields

schema: u32

producer: String

what produced this set: discovery for the offline path, or learn:<model> when a model proposed it

created: String

RFC3339 timestamp, or empty where no clock is available

categories: Vec<CategoryRecord>

gazetteer: Vec<Registration>

Registered mentions: the surface as it appears in text, and the canonical token it resolves to.

A mapping rather than a list because registration NORMALISES — leading determiners and trailing status words are stripped, so several surfaces can share one token and their postings merge. Recording only the surfaces would drop that, and two variants of one entity would become two entities.

relations: Vec<String>

relation verbs, canonical form

motifs: Vec<CategoryRecord>

latent motifs, in the same shape as a category: a name and the terms that join it

digests: BTreeMap<String, usize>

byte lengths of each written part, so a truncated set is detected on load

training_examples: usize

Number of labelled examples written under training/, if any.

The count lives in the manifest but the examples do not, because they contain corpus text and the manifest is meant to be readable and committable.

contains_document_text: Vec<String>

Parts of this set that contain verbatim document text. Always empty for the vocabulary files; lists training/ when a finetuning set was written.

Recorded explicitly so a tool, a reviewer, or a CI check can tell which parts are safe to publish without having to know the layout by heart.

Implementations

impl Artifacts

pub fn new( producer: impl Into<String>, categories: Vec<CategoryRecord>, gazetteer: Vec<Registration>, relations: Vec<String>, ) -> Artifacts

Build a set from the parts an ingest produced.

pub fn with_training(self, jsonl: impl Into<String>) -> Artifacts

Attach a finetuning set: JSONL lines, one labelled passage each.

This is the one part of an artefact set that carries document text — a span label is meaningless without the words it points at. It is therefore written to a subdirectory, recorded in contains_document_text, and excluded by a .gitignore that Artifacts::save writes, so committing the artefact directory does not commit the corpus by accident.

pub fn training(&self) -> Option<&str>

The finetuning set, if this build of the artefacts carries one in memory.

pub fn with_motifs(self, motifs: Vec<CategoryRecord>) -> Artifacts

Write the set to dir, creating it if needed.

Each part is written separately so a reviewer sees a small, meaningful diff rather than one large blob. Record the discovered motifs, so a reload projects the same motif/* tokens discovery did.

pub fn save(&self, dir: impl AsRef<Path>) -> Result<(), ArtifactError>

pub fn load(dir: impl AsRef<Path>) -> Result<Artifacts, ArtifactError>

Read a set from dir, refusing anything this build cannot interpret correctly.

pub fn exists(dir: impl AsRef<Path>) -> bool

True when dir holds a readable artefact set.

Trait Implementations

impl Clone for Artifacts

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Artifacts

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Artifacts

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Artifacts

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.