use crate::processed::model::ProcessedDescriptor;
use crate::provenance::CanonicalDatasetDigests;
use crate::provenance::SampleNormalization;
use crate::provenance::SourceFile;
use self::validation::output_lineage;
use super::{ExecutionSegment, ProcessingRecord};
#[derive(Clone, Debug, PartialEq)]
pub struct ProcessingHistory {
initial_descriptor: ProcessedDescriptor,
inputs: Vec<HistoryInput>,
axis_lineage: Vec<crate::provenance::InputAxisRef>,
records: Vec<ProcessingRecord>,
segments: Vec<ExecutionSegment>,
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum HistoryInput {
#[non_exhaustive]
Raw {
digests: CanonicalDatasetDigests,
normalization: SampleNormalization,
format: Option<crate::raw::RawFormat>,
sources: Vec<SourceFile>,
},
#[non_exhaustive]
Processed {
digests: CanonicalDatasetDigests,
sources: Vec<SourceFile>,
read_record: Option<crate::provenance::ProcessedReadRecord>,
},
}
impl HistoryInput {
pub fn digests(&self) -> CanonicalDatasetDigests {
match self {
Self::Raw { digests, .. } | Self::Processed { digests, .. } => *digests,
}
}
pub fn sources(&self) -> &[SourceFile] {
match self {
Self::Raw { sources, .. } | Self::Processed { sources, .. } => sources,
}
}
}
impl ProcessingHistory {
pub(crate) fn accept_archived_history(&mut self) {
for segment in &mut self.segments {
segment.accept_archive();
}
}
pub fn initial_descriptor(&self) -> &ProcessedDescriptor {
&self.initial_descriptor
}
pub fn records(&self) -> &[ProcessingRecord] {
&self.records
}
pub fn segments(&self) -> &[ExecutionSegment] {
&self.segments
}
pub(crate) fn inherit_segments(&mut self, previous: Option<&Self>) {
self.segments = previous.map_or_else(Vec::new, |history| history.segments.clone());
}
pub(crate) fn finish_segment(&mut self, output: CanonicalDatasetDigests) {
self.segments
.push(ExecutionSegment::new(self.records.len(), output));
}
pub(crate) fn prefix(&self, end: usize) -> Self {
Self {
initial_descriptor: self.initial_descriptor.clone(),
inputs: self.inputs.clone(),
axis_lineage: self.axis_lineage.clone(),
records: self.records[..end].to_vec(),
segments: Vec::new(),
}
}
pub fn raw_input_digests(&self) -> Option<CanonicalDatasetDigests> {
match self.input() {
HistoryInput::Raw { digests, .. } => Some(*digests),
_ => None,
}
}
pub fn raw_input_normalization(&self) -> Option<&SampleNormalization> {
match self.input() {
HistoryInput::Raw { normalization, .. } => Some(normalization),
_ => None,
}
}
pub fn input(&self) -> &HistoryInput {
&self.inputs[0]
}
pub fn inputs(&self) -> &[HistoryInput] {
&self.inputs
}
pub fn axis_lineage(&self) -> &[crate::provenance::InputAxisRef] {
&self.axis_lineage
}
pub(crate) fn new(
initial_descriptor: ProcessedDescriptor,
input: HistoryInput,
records: Vec<ProcessingRecord>,
) -> Self {
Self {
axis_lineage: output_lineage(initial_descriptor.axes().len(), &records),
initial_descriptor,
inputs: vec![input],
records,
segments: Vec::new(),
}
}
}
impl ProcessingHistory {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&ProcessedDescriptor,
&Vec<HistoryInput>,
&Vec<crate::provenance::InputAxisRef>,
&Vec<ProcessingRecord>,
&Vec<ExecutionSegment>,
) {
(
&self.initial_descriptor,
&self.inputs,
&self.axis_lineage,
&self.records,
&self.segments,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
ProcessedDescriptor,
Vec<HistoryInput>,
Vec<crate::provenance::InputAxisRef>,
Vec<ProcessingRecord>,
Vec<ExecutionSegment>,
),
) -> Result<Self, crate::internal::ModelError> {
let (initial_descriptor, inputs, axis_lineage, records, segments) = parts;
let value = Self {
initial_descriptor,
inputs,
axis_lineage,
records,
segments,
};
Ok(value)
}
}
#[cfg(test)]
mod tests;
pub(super) mod validation;