pacha 0.2.5

Model, Data and Recipe Registry with full lineage tracking
Documentation 
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Model registry types and operations.
//!
//! Provides model versioning, model cards, and lifecycle management.

mod card;
mod stage;
mod version;

pub use card::ModelCard;
pub use stage::ModelStage;
pub use version::ModelVersion;

use crate::storage::ContentAddress;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

/// Unique identifier for a registered model.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ModelId(Uuid);

impl ModelId {
    /// Create a new random model ID.
    #[must_use]
    pub fn new() -> Self {
        Self(Uuid::new_v4())
    }

    /// Create from a UUID.
    #[must_use]
    pub fn from_uuid(uuid: Uuid) -> Self {
        Self(uuid)
    }

    /// Get the underlying UUID.
    #[must_use]
    pub fn as_uuid(&self) -> &Uuid {
        &self.0
    }
}

impl Default for ModelId {
    fn default() -> Self {
        Self::new()
    }
}

impl std::fmt::Display for ModelId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl std::str::FromStr for ModelId {
    type Err = uuid::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Self(Uuid::parse_str(s)?))
    }
}

/// Reference to a model (name + version).
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ModelReference {
    /// Model name.
    pub name: String,
    /// Model version.
    pub version: ModelVersion,
}

impl ModelReference {
    /// Create a new model reference.
    #[must_use]
    pub fn new(name: impl Into<String>, version: ModelVersion) -> Self {
        Self {
            name: name.into(),
            version,
        }
    }
}

impl std::fmt::Display for ModelReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}:{}", self.name, self.version)
    }
}

/// A registered model in the registry.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Model {
    /// Unique identifier.
    pub id: ModelId,
    /// Model name.
    pub name: String,
    /// Model version.
    pub version: ModelVersion,
    /// Content address of the artifact.
    pub content_address: ContentAddress,
    /// Model card with metadata.
    pub card: ModelCard,
    /// Current lifecycle stage.
    pub stage: ModelStage,
    /// Registration timestamp.
    pub created_at: DateTime<Utc>,
    /// Last updated timestamp.
    pub updated_at: DateTime<Utc>,
}

impl Model {
    /// Create a reference to this model.
    #[must_use]
    pub fn reference(&self) -> ModelReference {
        ModelReference::new(&self.name, self.version.clone())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_model_id_generation() {
        let id1 = ModelId::new();
        let id2 = ModelId::new();
        assert_ne!(id1, id2);
    }

    #[test]
    fn test_model_id_from_str() {
        let id = ModelId::new();
        let s = id.to_string();
        let parsed: ModelId = s.parse().unwrap();
        assert_eq!(id, parsed);
    }

    #[test]
    fn test_model_reference_display() {
        let reference = ModelReference::new("fraud-detector", ModelVersion::new(1, 2, 3));
        assert_eq!(reference.to_string(), "fraud-detector:1.2.3");
    }
}