iztro 0.9.0

Strongly typed Zi Wei Dou Shu chart generation aligned with iztro.
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
142

use crate::features::Domain;
use serde::{Deserialize, Serialize};

/// Polarity of an interpretive claim.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ClaimPolarity {
    /// Supportive or favorable signal.
    Positive,
    /// Obstructive or unfavorable signal.
    Negative,
    /// Mixed signal with mostly supportive framing.
    MixedPositive,
    /// Mixed signal with mostly cautionary framing.
    MixedNegative,
    /// Neutral descriptive signal.
    Neutral,
}

/// Auditable source metadata for rules and claims.
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct SourceMetadata {
    rule_set: String,
    source_id: String,
}

impl SourceMetadata {
    /// Creates source metadata.
    pub fn new(rule_set: impl Into<String>, source_id: impl Into<String>) -> Self {
        Self {
            rule_set: rule_set.into(),
            source_id: source_id.into(),
        }
    }

    /// Returns the rule-set identifier.
    pub fn rule_set(&self) -> &str {
        &self.rule_set
    }

    /// Returns the source identifier.
    pub fn source_id(&self) -> &str {
        &self.source_id
    }
}

/// Chart or feature fact used as evidence for a claim.
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct Evidence {
    fact_key: String,
    summary: String,
}

impl Evidence {
    /// Creates an evidence item.
    pub fn new(fact_key: impl Into<String>, summary: impl Into<String>) -> Self {
        Self {
            fact_key: fact_key.into(),
            summary: summary.into(),
        }
    }

    /// Returns the stable fact key.
    pub fn fact_key(&self) -> &str {
        &self.fact_key
    }

    /// Returns the evidence summary.
    pub fn summary(&self) -> &str {
        &self.summary
    }
}

/// Structured rule output consumed by the reading layer.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Claim {
    domain: Domain,
    themes: Vec<String>,
    polarity: ClaimPolarity,
    strength: f32,
    evidence: Vec<Evidence>,
    counter_evidence: Vec<Evidence>,
    source: SourceMetadata,
}

impl Claim {
    /// Creates a structured claim.
    pub fn new(
        domain: Domain,
        themes: Vec<String>,
        polarity: ClaimPolarity,
        strength: f32,
        evidence: Vec<Evidence>,
        counter_evidence: Vec<Evidence>,
        source: SourceMetadata,
    ) -> Self {
        Self {
            domain,
            themes,
            polarity,
            strength,
            evidence,
            counter_evidence,
            source,
        }
    }

    /// Returns the claim domain.
    pub const fn domain(&self) -> Domain {
        self.domain
    }

    /// Returns claim themes.
    pub fn themes(&self) -> &[String] {
        &self.themes
    }

    /// Returns the claim polarity.
    pub const fn polarity(&self) -> ClaimPolarity {
        self.polarity
    }

    /// Returns the claim strength.
    pub const fn strength(&self) -> f32 {
        self.strength
    }

    /// Returns supporting evidence.
    pub fn evidence(&self) -> &[Evidence] {
        &self.evidence
    }

    /// Returns counter-evidence.
    pub fn counter_evidence(&self) -> &[Evidence] {
        &self.counter_evidence
    }

    /// Returns source metadata.
    pub const fn source(&self) -> &SourceMetadata {
        &self.source
    }
}