add language crate for conversions (#332)

Author: yujonglee

Cargo.lock

@@ -30,6 +30,7 @@ hypr-file = { path = "crates/file", package = "file" }
 hypr-gbnf = { path = "crates/gbnf", package = "gbnf" }
 hypr-gguf = { path = "crates/gguf", package = "gguf" }
 hypr-host = { path = "crates/host", package = "host" }
+hypr-language = { path = "crates/language", package = "language" }
 hypr-llama = { path = "crates/llama", package = "llama" }
 hypr-loops = { path = "crates/loops", package = "loops" }
 hypr-nango = { path = "crates/nango", package = "nango" }

Cargo.toml

@@ -7,14 +7,21 @@ use store::*;
 
 use tauri_plugin_windows::{HyprWindow, WindowsPluginExt};
 
-use tracing_subscriber::{prelude::__tracing_subscriber_SubscriberExt, util::SubscriberInitExt};
+use tracing_subscriber::{
+    fmt, prelude::__tracing_subscriber_SubscriberExt, util::SubscriberInitExt, EnvFilter,
+};
 
 #[tokio::main]
 pub async fn main() {
     tauri::async_runtime::set(tokio::runtime::Handle::current());
 
     {
+        let env_filter =
+            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+
         tracing_subscriber::Registry::default()
+            .with(fmt::layer())
+            .with(env_filter)
             .with(tauri_plugin_sentry::sentry::integrations::tracing::layer())
             .init();
     }

apps/desktop/src-tauri/src/lib.rs

@@ -8,6 +8,7 @@ hypr-buffer = { workspace = true }
 hypr-calendar-interface = { workspace = true }
 hypr-data = { workspace = true }
 hypr-db-core = { workspace = true }
+hypr-language = { workspace = true }
 hypr-listener-interface = { workspace = true }
 hypr-timeline = { workspace = true }
 

crates/db-user/Cargo.toml

@@ -1,4 +1,3 @@
-use codes_iso_639::part_1::LanguageCode;
 use serde::Deserialize;
 use std::str::FromStr;
 
@@ -40,8 +39,8 @@ user_common_derives! {
         pub autostart: bool,
         #[specta(type = String)]
         #[schemars(with = "String", regex(pattern = "^[a-zA-Z]{2}$"))]
-        #[serde(serialize_with = "serialize_language_code", deserialize_with = "deserialize_language_code")]
-        pub display_language: LanguageCode,
+        #[serde(serialize_with = "serialize_language", deserialize_with = "deserialize_language")]
+        pub display_language: hypr_language::Language,
         pub jargons: Vec<String>,
         pub telemetry_consent: bool,
     }
@@ -51,7 +50,7 @@ impl Default for ConfigGeneral {
     fn default() -> Self {
         Self {
             autostart: false,
-            display_language: LanguageCode::En,
+            display_language: hypr_language::ISO639::En.into(),
             jargons: vec![],
             telemetry_consent: true,
         }
@@ -85,16 +84,18 @@ user_common_derives! {
     }
 }
 
-fn serialize_language_code<S: serde::Serializer>(
-    code: &LanguageCode,
+fn serialize_language<S: serde::Serializer>(
+    lang: &hypr_language::Language,
     serializer: S,
 ) -> Result<S::Ok, S::Error> {
-    serializer.serialize_str(code.code())
+    let code = lang.iso639().code();
+    serializer.serialize_str(code)
 }
 
-fn deserialize_language_code<'de, D: serde::Deserializer<'de>>(
+fn deserialize_language<'de, D: serde::Deserializer<'de>>(
     deserializer: D,
-) -> Result<LanguageCode, D::Error> {
-    let s = String::deserialize(deserializer)?;
-    LanguageCode::from_str(&s).map_err(serde::de::Error::custom)
+) -> Result<hypr_language::Language, D::Error> {
+    let str = String::deserialize(deserializer)?;
+    let iso639 = hypr_language::ISO639::from_str(&str).map_err(serde::de::Error::custom)?;
+    Ok(iso639.into())
 }

crates/db-user/src/config_types.rs

@@ -0,0 +1,18 @@
+[package]
+name = "language"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+default = ["whisper"]
+whisper = ["dep:hypr-whisper"]
+deepgram = ["dep:deepgram"]
+
+[dependencies]
+codes-iso-639 = { workspace = true }
+
+deepgram = { workspace = true, optional = true, features = ["listen"] }
+hypr-whisper = { workspace = true, optional = true }
+
+serde = { workspace = true }
+thiserror = { workspace = true }

crates/language/Cargo.toml

@@ -0,0 +1,16 @@
+use serde::{ser::Serializer, Serialize};
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Not supported language: {0}")]
+    NotSupportedLanguage(codes_iso_639::part_1::LanguageCode),
+}
+
+impl Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}

crates/language/src/error.rs

@@ -0,0 +1,184 @@
+mod error;
+pub use error::*;
+
+pub use codes_iso_639::part_1::LanguageCode as ISO639;
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Language {
+    iso639: ISO639,
+}
+
+impl Default for Language {
+    fn default() -> Self {
+        Self { iso639: ISO639::En }
+    }
+}
+
+impl From<ISO639> for Language {
+    fn from(language: ISO639) -> Self {
+        Self { iso639: language }
+    }
+}
+
+impl std::ops::Deref for Language {
+    type Target = ISO639;
+
+    fn deref(&self) -> &Self::Target {
+        &self.iso639
+    }
+}
+
+impl Language {
+    pub fn iso639(&self) -> ISO639 {
+        self.iso639
+    }
+
+    #[cfg(feature = "whisper")]
+    pub fn for_whisper(self) -> Result<hypr_whisper::Language, Error> {
+        use hypr_whisper::Language as WL;
+
+        match self.iso639 {
+            ISO639::Af => Ok(WL::Af),
+            ISO639::Am => Ok(WL::Am),
+            ISO639::Ar => Ok(WL::Ar),
+            ISO639::As => Ok(WL::As),
+            ISO639::Az => Ok(WL::Az),
+            ISO639::Ba => Ok(WL::Ba),
+            ISO639::Be => Ok(WL::Be),
+            ISO639::Bg => Ok(WL::Bg),
+            ISO639::Bn => Ok(WL::Bn),
+            ISO639::Bo => Ok(WL::Bo),
+            ISO639::Br => Ok(WL::Br),
+            ISO639::Bs => Ok(WL::Bs),
+            ISO639::Ca => Ok(WL::Ca),
+            ISO639::Cs => Ok(WL::Cs),
+            ISO639::Cy => Ok(WL::Cy),
+            ISO639::Da => Ok(WL::Da),
+            ISO639::De => Ok(WL::De),
+            ISO639::El => Ok(WL::El),
+            ISO639::En => Ok(WL::En),
+            ISO639::Es => Ok(WL::Es),
+            ISO639::Et => Ok(WL::Et),
+            ISO639::Eu => Ok(WL::Eu),
+            ISO639::Fa => Ok(WL::Fa),
+            ISO639::Fi => Ok(WL::Fi),
+            ISO639::Fo => Ok(WL::Fo),
+            ISO639::Fr => Ok(WL::Fr),
+            ISO639::Gl => Ok(WL::Gl),
+            ISO639::Gu => Ok(WL::Gu),
+            ISO639::Ha => Ok(WL::Ha),
+            ISO639::He => Ok(WL::He),
+            ISO639::Hi => Ok(WL::Hi),
+            ISO639::Hr => Ok(WL::Hr),
+            ISO639::Ht => Ok(WL::Ht),
+            ISO639::Hu => Ok(WL::Hu),
+            ISO639::Hy => Ok(WL::Hy),
+            ISO639::Id => Ok(WL::Id),
+            ISO639::Is => Ok(WL::Is),
+            ISO639::It => Ok(WL::It),
+            ISO639::Ja => Ok(WL::Ja),
+            ISO639::Jv => Ok(WL::Jw),
+            ISO639::Ka => Ok(WL::Ka),
+            ISO639::Kk => Ok(WL::Kk),
+            ISO639::Km => Ok(WL::Km),
+            ISO639::Kn => Ok(WL::Kn),
+            ISO639::Ko => Ok(WL::Ko),
+            ISO639::La => Ok(WL::La),
+            ISO639::Lb => Ok(WL::Lb),
+            ISO639::Lo => Ok(WL::Lo),
+            ISO639::Lt => Ok(WL::Lt),
+            ISO639::Lv => Ok(WL::Lv),
+            ISO639::Mg => Ok(WL::Mg),
+            ISO639::Mi => Ok(WL::Mi),
+            ISO639::Mk => Ok(WL::Mk),
+            ISO639::Ml => Ok(WL::Ml),
+            ISO639::Mn => Ok(WL::Mn),
+            ISO639::Mr => Ok(WL::Mr),
+            ISO639::Ms => Ok(WL::Ms),
+            ISO639::Mt => Ok(WL::Mt),
+            ISO639::My => Ok(WL::My),
+            ISO639::Ne => Ok(WL::Ne),
+            ISO639::Nl => Ok(WL::Nl),
+            ISO639::Nn => Ok(WL::Nn),
+            ISO639::No => Ok(WL::No),
+            ISO639::Oc => Ok(WL::Oc),
+            ISO639::Pa => Ok(WL::Pa),
+            ISO639::Pl => Ok(WL::Pl),
+            ISO639::Ps => Ok(WL::Ps),
+            ISO639::Pt => Ok(WL::Pt),
+            ISO639::Ro => Ok(WL::Ro),
+            ISO639::Ru => Ok(WL::Ru),
+            ISO639::Sa => Ok(WL::Sa),
+            ISO639::Sd => Ok(WL::Sd),
+            ISO639::Si => Ok(WL::Si),
+            ISO639::Sk => Ok(WL::Sk),
+            ISO639::Sl => Ok(WL::Sl),
+            ISO639::Sn => Ok(WL::Sn),
+            ISO639::So => Ok(WL::So),
+            ISO639::Sq => Ok(WL::Sq),
+            ISO639::Sr => Ok(WL::Sr),
+            ISO639::Su => Ok(WL::Su),
+            ISO639::Sv => Ok(WL::Sv),
+            ISO639::Sw => Ok(WL::Sw),
+            ISO639::Ta => Ok(WL::Ta),
+            ISO639::Te => Ok(WL::Te),
+            ISO639::Tg => Ok(WL::Tg),
+            ISO639::Th => Ok(WL::Th),
+            ISO639::Tk => Ok(WL::Tk),
+            ISO639::Tl => Ok(WL::Tl),
+            ISO639::Tr => Ok(WL::Tr),
+            ISO639::Tt => Ok(WL::Tt),
+            ISO639::Uk => Ok(WL::Uk),
+            ISO639::Ur => Ok(WL::Ur),
+            ISO639::Uz => Ok(WL::Uz),
+            ISO639::Vi => Ok(WL::Vi),
+            ISO639::Yi => Ok(WL::Yi),
+            ISO639::Yo => Ok(WL::Yo),
+            ISO639::Zh => Ok(WL::Zh),
+            _ => Err(Error::NotSupportedLanguage(self.iso639)),
+        }
+    }
+
+    #[cfg(feature = "deepgram")]
+    pub fn for_deepgram(self) -> Result<deepgram::common::options::Language, Error> {
+        use deepgram::common::options::Language as DG;
+
+        match self.iso639 {
+            ISO639::Bg => Ok(DG::bg),
+            ISO639::Ca => Ok(DG::ca),
+            ISO639::Cs => Ok(DG::cs),
+            ISO639::Da => Ok(DG::da),
+            ISO639::De => Ok(DG::de),
+            ISO639::El => Ok(DG::el),
+            ISO639::En => Ok(DG::en),
+            ISO639::Es => Ok(DG::es),
+            ISO639::Et => Ok(DG::et),
+            ISO639::Fi => Ok(DG::fi),
+            ISO639::Fr => Ok(DG::fr),
+            ISO639::Hi => Ok(DG::hi),
+            ISO639::Hu => Ok(DG::hu),
+            ISO639::Id => Ok(DG::id),
+            ISO639::It => Ok(DG::it),
+            ISO639::Ja => Ok(DG::ja),
+            ISO639::Ko => Ok(DG::ko),
+            ISO639::Lt => Ok(DG::lt),
+            ISO639::Lv => Ok(DG::lv),
+            ISO639::Ms => Ok(DG::ms),
+            ISO639::Nl => Ok(DG::nl),
+            ISO639::No => Ok(DG::no),
+            ISO639::Pl => Ok(DG::pl),
+            ISO639::Pt => Ok(DG::pt),
+            ISO639::Ro => Ok(DG::ro),
+            ISO639::Ru => Ok(DG::ru),
+            ISO639::Sk => Ok(DG::sk),
+            ISO639::Sv => Ok(DG::sv),
+            ISO639::Ta => Ok(DG::ta),
+            ISO639::Th => Ok(DG::th),
+            ISO639::Tr => Ok(DG::tr),
+            ISO639::Uk => Ok(DG::uk),
+            ISO639::Vi => Ok(DG::vi),
+            ISO639::Zh => Ok(DG::zh),
+            _ => Err(Error::NotSupportedLanguage(self.iso639)),
+        }
+    }
+}