work on getting example work; still broken but progress

Author: C-Loftus

ssip-client-async/examples/automatic_language_detection.rs

@@ -3,19 +3,25 @@ use ssip_client_async::{fifo, ClientResult};
 
 #[cfg(all(unix, not(feature = "async-mio")))]
 fn main() -> ClientResult<()> {
-    // spawn the speech-dispatcher daemon before creating the client
-    // and trying to connect to the speech-dispatcher socket
-    let languages = vec![lingua::IsoCode639_3::ENG, lingua::IsoCode639_3::SPA];
+    use ssip::ClientName;
+
+    let languages = vec![lingua::IsoCode639_1::EN, lingua::IsoCode639_1::RU];
     let mut client = fifo::Builder::new()
-        .with_language_detection(&languages)
+        // initialize the language detection model with a list of languages to distinguish between
+        .with_automatic_detection_languages(&languages)
+        // spawn the speech-dispatcher daemon before creating the client
+        // and trying to connect to the speech-dispatcher socket
         .with_spawn()?
         .build()?;
 
     client
+        .set_client_name(ClientName::new("sasha", "example_app"))?
+        .check_client_name_set()?
         .speak()?
         .check_receiving_data()?
-        .send_line("test message for the spawn example")?
-        .receive_message_id()?;
+        .send_lines_multilingual(
+            &"Hello, my name is Joe. меня зовут джо".to_string(),
+        )?;
 
     client.quit()?.receive()?;
     Ok(())

ssip-client-async/src/client.rs

@@ -20,6 +20,7 @@ use crate::types::*;
 #[cfg(all(not(feature = "async-mio"), unix))]
 pub use std::os::unix::io::AsRawFd as Source;
 
+use lingua::LanguageDetector;
 #[cfg(feature = "async-mio")]
 pub use mio::event::Source;
 
@@ -69,13 +70,22 @@ macro_rules! send_range {
 pub struct Client<S: Read + Write + Source> {
     input: io::BufReader<S>,
     output: io::BufWriter<S>,
+    pub language_detector: Option<LanguageDetector>,
 }
 
 impl<S: Read + Write + Source> Client<S> {
     /// Create a SSIP client on the reader and writer.
-    pub(crate) fn new(input: io::BufReader<S>, output: io::BufWriter<S>) -> Self {
+    pub(crate) fn new(
+        input: io::BufReader<S>,
+        output: io::BufWriter<S>,
+        language_detector: Option<LanguageDetector>,
+    ) -> Self {
         // https://stackoverflow.com/questions/58467659/how-to-store-tcpstream-with-bufreader-and-bufwriter-in-a-data-structure
-        Self { input, output }
+        Self {
+            input,
+            output,
+            language_detector,
+        }
     }
 
     #[cfg(all(not(feature = "async-mio"), unix))]

ssip-client-async/src/fifo.rs

@@ -66,15 +66,15 @@ mod synchronous {
     pub struct Builder {
         path: FifoPath,
         mode: StreamMode,
-        pub language_detector_model: Option<lingua::LanguageDetector>,
+        pub languages_to_detect: Option<Vec<lingua::IsoCode639_1>>,
     }
 
     impl Builder {
         pub fn new() -> Self {
             Self {
                 path: FifoPath::new(),
                 mode: StreamMode::Blocking,
-                language_detector_model: None,
+                languages_to_detect: None,
             }
         }
 
@@ -105,6 +105,17 @@ mod synchronous {
             Ok(self)
         }
 
+        fn init_language_detector(
+            languages: &Vec<lingua::IsoCode639_1>,
+        ) -> Option<lingua::LanguageDetector> {
+            Some(
+                lingua::LanguageDetectorBuilder::from_iso_codes_639_1(languages)
+                    // preload all language models into memory for faster client detection
+                    .with_preloaded_language_models()
+                    .build(),
+            )
+        }
+
         pub fn build(&self) -> io::Result<Client<UnixStream>> {
             let input = UnixStream::connect(self.path.get()?)?;
             match self.mode {
@@ -114,7 +125,21 @@ mod synchronous {
             }
 
             let output = input.try_clone()?;
-            Ok(Client::new(BufReader::new(input), BufWriter::new(output)))
+            match &self.languages_to_detect {
+                Some(languages) => {
+                    let language_detector = Self::init_language_detector(&languages).unwrap();
+                    Ok(Client::new(
+                        BufReader::new(input),
+                        BufWriter::new(output),
+                        Some(language_detector),
+                    ))
+                }
+                None => Ok(Client::new(
+                    BufReader::new(input),
+                    BufWriter::new(output),
+                    None,
+                )),
+            }
         }
     }
 }

ssip-client-async/src/language_detection.rs

@@ -3,27 +3,42 @@ use std::io::{Read, Write};
 #[cfg(all(not(feature = "async-mio"), unix))]
 pub use std::os::unix::io::AsRawFd as Source;
 
-use crate::{fifo::Builder, Client};
-use lingua::IsoCode639_3;
-use ssip::ClientResult;
+use crate::{fifo::Builder, Client, OK_LANGUAGE_SET};
+use lingua::IsoCode639_1;
+use ssip::{ClientError, ClientResult};
 
 impl Builder {
     /// Initialize the language detection model with a list of languages to distinguish between
     /// Use the ISO 639-3 language codes to distinguish between languages
-    pub fn with_language_detection(&mut self, languages: &Vec<IsoCode639_3>) -> &mut Self {
-        self.language_detector_model = Some(
-            lingua::LanguageDetectorBuilder::from_iso_codes_639_3(languages)
-                // preload all language models into memory for faster client detection
-                .with_preloaded_language_models()
-                .build(),
-        );
+    pub fn with_automatic_detection_languages(
+        &mut self,
+        languages: &Vec<IsoCode639_1>,
+    ) -> &mut Self {
+        self.languages_to_detect = Some(languages.clone());
         self
     }
 }
 
 impl<S: Read + Write + Source> Client<S> {
     /// A wrapper over the `send_lines` method to send lines in multiple languages
-    pub fn send_lines_multilingual(&mut self, lines: &[String]) -> ClientResult<()> {
-        Ok(())
+    pub fn send_lines_multilingual(&mut self, lines: &String) -> ClientResult<&mut Self> {
+        let detector =
+            self.language_detector
+                .as_ref()
+                .ok_or(ClientError::LanguageDetectionError(
+                    "Language detection not initialized".to_string(),
+                ))?;
+
+        let detection_results = detector.detect_multiple_languages_of(lines);
+
+        for result in detection_results {
+            let language_code = result.language().iso_code_639_1().to_string();
+            // the status check stalls for some reason and never returns
+            self.set_language(ssip::ClientScope::Current, &language_code)?.check_status(OK_LANGUAGE_SET)?;
+            let subsection = lines[result.start_index()..result.end_index()].to_string();
+            self.send_lines(&[subsection])?.receive()?;
+        }
+
+        Ok(self)
     }
 }

ssip-client-async/src/tcp.rs

@@ -58,7 +58,11 @@ mod synchronous {
                 StreamMode::TimeOut(timeout) => input.set_read_timeout(Some(timeout))?,
             }
             let output = input.try_clone()?;
-            Ok(Client::new(BufReader::new(input), BufWriter::new(output)))
+            Ok(Client::new(
+                BufReader::new(input),
+                BufWriter::new(output),
+                None,
+            ))
         }
     }
 }

ssip/src/lib.rs

@@ -417,6 +417,8 @@ pub enum ClientError {
     TooManyLines,
     #[error("Unexpected status: {0}")]
     UnexpectedStatus(ReturnCode),
+    #[error("Failure automatically detecting language: {0}")]
+    LanguageDetectionError(String),
 }
 
 impl ClientError {