gaze-pii 0.6.6

Reversible PII pseudonymization runtime for agentic workflows
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

use crate::context::Context;
pub use gaze_types::{
    DictionaryBundle, DictionaryEntry, DictionaryLoadError, DictionarySource, DictionaryStats,
    RulepackDict,
};

pub trait DictionaryBundleExt {
    fn from_context(ctx: &Context) -> Self;
}

impl DictionaryBundleExt for DictionaryBundle {
    fn from_context(ctx: &Context) -> Self {
        dictionary_bundle_from_context(ctx)
    }
}

pub fn dictionary_bundle_from_context(ctx: &Context) -> DictionaryBundle {
    let entries = ctx.dictionaries.iter().map(|(name, dictionary)| {
        (
            name.clone(),
            DictionaryEntry::new(
                name,
                dictionary.terms.clone(),
                dictionary.case_sensitive,
                DictionarySource::Cli,
            )
            .expect("Context validates dictionary terms before bundle construction"),
        )
    });
    DictionaryBundle::from_entries(entries)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{ContextDictionary, PiiClass};
    use serde_json::Map;
    use std::collections::HashMap;

    #[test]
    fn context_bundle_builds_automata_per_request() {
        let ctx = Context {
            dictionaries: HashMap::from([(
                "dict_alpha".to_string(),
                ContextDictionary {
                    terms: vec!["AAA-12345".to_string()],
                    case_sensitive: true,
                },
            )]),
            class_map: HashMap::from([(
                "dict_alpha".to_string(),
                PiiClass::Custom("class_alpha".to_string()),
            )]),
            fields: Map::new(),
        };

        let bundle = dictionary_bundle_from_context(&ctx);
        let entry = bundle.get("dict_alpha").expect("entry");
        assert_eq!(entry.terms(), &["AAA-12345".to_string()]);
        assert!(entry.case_sensitive());
    }

    #[test]
    fn merge_prefers_second_bundle_for_same_name() {
        let a = DictionaryBundle::from_rulepack_terms(&[RulepackDict::new(
            "songs",
            vec!["Song A".to_string()],
            true,
        )]);
        let b = DictionaryBundle::from_rulepack_terms(&[RulepackDict::new(
            "songs",
            vec!["Song B".to_string()],
            true,
        )]);

        let merged = DictionaryBundle::merge(a, b);
        let entry = merged.get("songs").expect("entry");
        assert_eq!(entry.terms(), &["Song B".to_string()]);
    }

    #[test]
    fn extension_trait_restores_from_context_constructor() {
        let ctx = Context {
            dictionaries: HashMap::from([(
                "dict_alpha".to_string(),
                ContextDictionary {
                    terms: vec!["AAA-12345".to_string()],
                    case_sensitive: true,
                },
            )]),
            class_map: HashMap::from([(
                "dict_alpha".to_string(),
                PiiClass::Custom("class_alpha".to_string()),
            )]),
            fields: Map::new(),
        };

        let bundle = DictionaryBundle::from_context(&ctx);
        assert!(bundle.get("dict_alpha").is_some());
    }
}