pii 0.1.0

PII detection and anonymization with deterministic, capability-aware NLP pipelines.
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

//! NER-backed recognizer that converts model spans into detections.
//!
//! This recognizer consumes `NlpArtifacts.ner` and emits detections with
//! model-provided scores. It respects capability flags, returning no
//! detections when NER is unavailable.

use crate::recognizers::Recognizer;
use crate::types::{Detection, DetectionExplanation, EntityType, NlpArtifacts};

/// Wraps NER spans from `NlpArtifacts` into detections.
#[derive(Clone, Debug)]
pub struct NerRecognizer {
    name: String,
    entity_map: Vec<(EntityType, EntityType)>,
}

impl NerRecognizer {
    /// Creates a new NER recognizer with optional entity remapping.
    pub fn new(name: impl Into<String>, entity_map: Vec<(EntityType, EntityType)>) -> Self {
        Self {
            name: name.into(),
            entity_map,
        }
    }

    fn map_entity(&self, entity: &EntityType) -> Option<EntityType> {
        self.entity_map
            .iter()
            .find(|(key, _)| key == entity)
            .map(|(_, entity)| entity.clone())
    }
}

impl Recognizer for NerRecognizer {
    fn name(&self) -> &str {
        &self.name
    }

    fn supported_entities(&self) -> &[EntityType] {
        &[]
    }

    fn analyze(&self, _text: &str, artifacts: &NlpArtifacts) -> Vec<Detection> {
        if !artifacts.capabilities.ner {
            return Vec::new();
        }
        artifacts
            .ner
            .iter()
            .filter_map(|span| {
                let entity_type = self
                    .map_entity(&span.entity_type)
                    .unwrap_or_else(|| span.entity_type.clone());
                Some(Detection {
                    entity_type,
                    start: span.start,
                    end: span.end,
                    score: span.score,
                    recognizer: self.name.clone(),
                    explanation: DetectionExplanation::Ner {
                        model: span.model.clone(),
                        raw_score: span.score,
                    },
                })
            })
            .collect()
    }
}