datasynth-eval 2.2.0

Evaluation framework for synthetic financial data quality and coherence
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

//! Data quality evaluation module.
//!
//! Validates data quality metrics including uniqueness, completeness,
//! format consistency, and cross-field consistency.

mod completeness;
mod consistency;
mod format;
mod uniqueness;

pub use completeness::{
    CompletenessAnalysis, CompletenessAnalyzer, FieldCompleteness, FieldDefinition, FieldValue,
};
pub use consistency::{ConsistencyAnalysis, ConsistencyAnalyzer, ConsistencyRule};
pub use format::{FormatAnalysis, FormatAnalyzer, FormatVariation};
pub use uniqueness::{DuplicateInfo, UniqueRecord, UniquenessAnalysis, UniquenessAnalyzer};

use serde::{Deserialize, Serialize};

/// Combined data quality evaluation results.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QualityEvaluation {
    /// Uniqueness analysis results.
    pub uniqueness: Option<UniquenessAnalysis>,
    /// Completeness analysis results.
    pub completeness: Option<CompletenessAnalysis>,
    /// Format consistency results.
    pub format: Option<FormatAnalysis>,
    /// Cross-field consistency results.
    pub consistency: Option<ConsistencyAnalysis>,
    /// Overall quality score (0.0-1.0).
    pub overall_score: f64,
    /// Whether quality meets thresholds.
    pub passes: bool,
    /// Quality issues found.
    pub issues: Vec<String>,
    /// Quality failures (alias for issues, used by report module).
    pub failures: Vec<String>,
}

impl QualityEvaluation {
    /// Create a new empty evaluation.
    pub fn new() -> Self {
        Self {
            uniqueness: None,
            completeness: None,
            format: None,
            consistency: None,
            overall_score: 1.0,
            passes: true,
            issues: Vec::new(),
            failures: Vec::new(),
        }
    }

    /// Check all results against thresholds.
    pub fn check_thresholds(&mut self, thresholds: &crate::config::EvaluationThresholds) {
        self.issues.clear();
        self.failures.clear();
        let mut scores = Vec::new();

        if let Some(ref uniqueness) = self.uniqueness {
            if uniqueness.duplicate_rate > thresholds.duplicate_rate_max {
                self.issues.push(format!(
                    "Duplicate rate {} > {} (threshold)",
                    uniqueness.duplicate_rate, thresholds.duplicate_rate_max
                ));
            }
            scores.push(1.0 - uniqueness.duplicate_rate);
        }

        if let Some(ref completeness) = self.completeness {
            if completeness.overall_completeness < thresholds.completeness_rate_min {
                self.issues.push(format!(
                    "Completeness {} < {} (threshold)",
                    completeness.overall_completeness, thresholds.completeness_rate_min
                ));
            }
            scores.push(completeness.overall_completeness);
        }

        if let Some(ref format) = self.format {
            if format.consistency_score < thresholds.format_consistency_min {
                self.issues.push(format!(
                    "Format consistency {} < {} (threshold)",
                    format.consistency_score, thresholds.format_consistency_min
                ));
            }
            scores.push(format.consistency_score);
        }

        if let Some(ref consistency) = self.consistency {
            // Use format consistency threshold for cross-field as they're related
            if consistency.pass_rate < thresholds.format_consistency_min {
                self.issues.push(format!(
                    "Cross-field consistency {} < {} (threshold)",
                    consistency.pass_rate, thresholds.format_consistency_min
                ));
            }
            scores.push(consistency.pass_rate);
        }

        self.overall_score = if scores.is_empty() {
            1.0
        } else {
            scores.iter().sum::<f64>() / scores.len() as f64
        };

        // Sync failures with issues
        self.failures = self.issues.clone();
        self.passes = self.issues.is_empty();
    }
}

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