rustfst 0.5.0

Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs).
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

use std::fmt::Display;

use failure::{format_err, Fallible};
use serde_derive::{Deserialize, Serialize};

use crate::algorithms::{determinize, isomorphic, DeterminizeType};
use crate::fst_properties::FstProperties;
use crate::fst_traits::{AllocableFst, MutableFst, SerializableFst};
use crate::semirings::SerializableSemiring;
use crate::semirings::WeaklyDivisibleSemiring;
use crate::semirings::WeightQuantize;
use crate::tests_openfst::FstTestData;

#[derive(Serialize, Deserialize, Debug)]
pub struct DeterminizeOperationResult {
    det_type: String,
    result: String,
}

pub struct DeterminizeTestData<F>
where
    F: SerializableFst,
    F::W: SerializableSemiring,
{
    det_type: DeterminizeType,
    result: Fallible<F>,
}

impl DeterminizeOperationResult {
    pub fn parse<F>(&self) -> DeterminizeTestData<F>
    where
        F: SerializableFst,
        F::W: SerializableSemiring,
    {
        DeterminizeTestData {
            det_type: match self.det_type.as_str() {
                "functional" => DeterminizeType::DeterminizeFunctional,
                "nonfunctional" => DeterminizeType::DeterminizeNonFunctional,
                "disambiguate" => DeterminizeType::DeterminizeDisambiguate,
                _ => panic!("Unknown determinize type : {:?}", self.det_type),
            },
            result: match self.result.as_str() {
                "error" => Err(format_err!("lol")),
                _ => F::from_text_string(self.result.as_str()),
            },
        }
    }
}

pub fn test_determinize<F>(test_data: &FstTestData<F>) -> Fallible<()>
where
    F: SerializableFst + MutableFst + AllocableFst + Display,
    F::W: SerializableSemiring + WeaklyDivisibleSemiring + WeightQuantize + 'static,
{
    for determinize_data in &test_data.determinize {
        //        println!("det_type = {:?}", determinize_data.det_type);
        let fst_raw = test_data.raw.clone();
        let fst_res: Fallible<F> = determinize(&fst_raw, determinize_data.det_type.clone());

        match (&determinize_data.result, fst_res) {
            (Ok(fst_expected), Ok(ref fst_determinized)) => {
                if determinize_data.det_type == DeterminizeType::DeterminizeFunctional {
                    assert!(fst_determinized
                        .properties()?
                        .contains(FstProperties::I_DETERMINISTIC));
                }
                let a = isomorphic(fst_expected, fst_determinized)?;
                assert!(
                    a,
                    "{}",
                    error_message_fst!(
                        fst_expected,
                        fst_determinized,
                        format!(
                            "Determinize fail for det_type = {:?} ",
                            determinize_data.det_type
                        )
                    )
                );
            }
            (Ok(_fst_expected), Err(_)) => panic!(
                "Determinize fail for det_type {:?}. Got Err. Expected Ok",
                determinize_data.det_type
            ),
            (Err(_), Ok(_fst_determinized)) => panic!(
                "Determinize fail for det_type {:?}. Got Ok. Expected Err, \n{}",
                determinize_data.det_type, _fst_determinized
            ),
            (Err(_), Err(_)) => {
                // Ok
            }
        };
    }
    Ok(())
}