annatto 0.50.1

Converts linguistic data formats based on the graphANNIS data model as intermediate representation and can apply consistency tests.
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

use std::collections::BTreeSet;

use graphannis::{graph::AnnoKey, model::AnnotationComponentType};
use graphannis_core::graph::ANNIS_NS;
use serde::Deserialize;

use crate::estarde::IntoInner;

use super::annotation_component::SerdeComponent;

#[test]
fn component() {
    let toml_str = r#"
ctype = "Pointing"
layer = "syntax"
name = "dependency"
"#;
    let r: Result<SerdeComponent, _> = toml::from_str(toml_str);
    assert!(r.is_ok());
    let dc = r.unwrap();
    let c = dc.into_inner();
    assert!(matches!(c.get_type(), AnnotationComponentType::Pointing));
    assert_eq!(c.layer.as_str(), "syntax");
    assert_eq!(c.name.as_str(), "dependency");
}

#[test]
fn aliased_component() {
    let toml_str = r#"
type = "Pointing"
layer = "syntax"
name = "dependency"
"#;
    let r: Result<SerdeComponent, _> = toml::from_str(toml_str);
    assert!(r.is_ok());
    let dc = r.unwrap();
    let c = dc.into_inner();
    assert!(matches!(c.get_type(), AnnotationComponentType::Pointing));
    assert_eq!(c.layer.as_str(), "syntax");
    assert_eq!(c.name.as_str(), "dependency");
}

#[derive(Deserialize)]
struct KeyOwner {
    #[serde(with = "crate::estarde::anno_key")]
    key: AnnoKey,
    #[serde(with = "crate::estarde::anno_key::as_option")]
    optional: Option<AnnoKey>,
    #[serde(with = "crate::estarde::anno_key::in_sequence")]
    seq: Vec<AnnoKey>,
    #[serde(with = "crate::estarde::anno_key::in_sequence")]
    unique_seq: BTreeSet<AnnoKey>,
}

#[test]
fn anno_key() {
    let with_strings = r#"
key = "annis::tok"
optional = "norm::norm"
seq = ["dipl", "dipl::cu", "norm::lemma"]
unique_seq = ["norm::pos", "norm::pos_lang"]
"#;
    let with_keys = r#"
key = { ns = "annis", name = "tok"}
optional = { ns = "norm", name = "norm" }
seq = [{ ns = "", name = "dipl" }, { ns = "dipl", name = "cu" }, { ns = "norm", name = "lemma" }]
unique_seq = [ { ns = "norm", name = "pos" }, { ns = "norm", name = "pos_lang" }]
"#;
    let frm_str: Result<KeyOwner, _> = toml::from_str(with_strings);
    assert!(
        frm_str.is_ok(),
        "Error deserializing from string keys: {:?}",
        frm_str.err()
    );
    let from_str = frm_str.unwrap();
    let frm_ks: Result<KeyOwner, _> = toml::from_str(with_keys);
    assert!(
        frm_ks.is_ok(),
        "Error deserializing from keys: {:?}",
        frm_ks.err()
    );
    let from_keys = frm_ks.unwrap();
    let tok = AnnoKey {
        ns: ANNIS_NS.into(),
        name: "tok".into(),
    };
    assert_eq!(from_str.key, from_keys.key);
    assert_eq!(from_str.key, tok);
    let norm_key = AnnoKey {
        ns: "norm".into(),
        name: "norm".into(),
    };
    assert!(from_str.optional.is_some());
    assert!(from_keys.optional.is_some());
    assert_eq!(&norm_key, from_str.optional.as_ref().unwrap());
    assert_eq!(&norm_key, from_keys.optional.as_ref().unwrap());
    let seq_keys = vec![
        AnnoKey {
            ns: "".into(),
            name: "dipl".into(),
        },
        AnnoKey {
            ns: "dipl".into(),
            name: "cu".into(),
        },
        AnnoKey {
            ns: "norm".into(),
            name: "lemma".into(),
        },
    ];
    assert_eq!(seq_keys.len(), from_str.seq.len());
    assert_eq!(from_keys.seq.len(), from_str.seq.len());
    for (k_exp, (k1, k2)) in seq_keys
        .iter()
        .zip(from_str.seq.iter().zip(from_keys.seq.iter()))
    {
        assert_eq!(k_exp, k1);
        assert_eq!(k1, k2);
    }
    let unique_keys: BTreeSet<AnnoKey> = vec![
        AnnoKey {
            ns: "norm".into(),
            name: "pos".into(),
        },
        AnnoKey {
            ns: "norm".into(),
            name: "pos_lang".into(),
        },
    ]
    .into_iter()
    .collect();
    assert_eq!(unique_keys, from_str.unique_seq);
    assert_eq!(from_keys.unique_seq, from_str.unique_seq);
}