piper-phoneme-streaming 0.1.0

A high-performance Rust library for streaming Text-to-Phoneme (G2P) conversion.
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

use crate::dictionary::Dictionary;
use crate::dictionary::stress::StressOpts;
use crate::embedded_data::materialized_data_dir;
use crate::error::{Error, Result};
use crate::phoneme::PhonemeData;
use crate::semantic::{Language, WordPhoneme};
use crate::translate::word_to_phonemes;

pub struct WordPhonemizer {
    language: Language,
    dict: Dictionary,
    phdata: PhonemeData,
    stress_opts: StressOpts,
}

impl WordPhonemizer {
    pub fn new(language: Language) -> Result<Self> {
        let data_dir = materialized_data_dir()?;
        let mut phdata = PhonemeData::load(data_dir)?;
        phdata.select_table_by_name(language.as_str())?;

        let dict = Dictionary::load(language.as_str(), data_dir)?;
        let stress_opts = StressOpts::for_lang(language.as_str());

        Ok(Self {
            language,
            dict,
            phdata,
            stress_opts,
        })
    }

    pub fn phonemize_word(&self, word: &str) -> Result<WordPhoneme> {
        if word.is_empty() {
            return Err(Error::InvalidData("word must not be empty".into()));
        }

        let normalized = word.to_lowercase();
        let result = word_to_phonemes(&normalized, &self.dict, &self.phdata, &self.stress_opts);

        Ok(WordPhoneme::from_raw(
            self.language,
            normalized,
            result.phonemes,
            result.dict_flags,
            &self.phdata,
        ))
    }

    pub fn language(&self) -> Language {
        self.language
    }
}