chore: use once_cell lazy instead of lazy_static

Cargo.lock

@@ -1449,7 +1449,7 @@ dependencies = [
  "aws-sdk-translate",
  "config",
  "futures-util",
- "lazy_static",
+ "once_cell",
  "poem",
  "serde",
  "serde_json",

Cargo.toml

@@ -12,7 +12,7 @@ aws-sdk-translate = "0.34"
 aws-sdk-polly = "0.34"
 config = "0.13"
 futures-util = "0.3"
-lazy_static = "1.4"
+once_cell = "1.18"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_yaml = "0.9"

src/config.rs

@@ -1,26 +1,12 @@
-use std::{ffi::c_int, net::IpAddr, env};
+use std::{env, ffi::c_int, net::IpAddr};
 
-use config::{Environment, Config, File};
-use lazy_static::lazy_static;
+use config::{Config, Environment, File};
+use once_cell::sync::Lazy;
 use serde::Deserialize;
 use whisper_rs::FullParams;
 
-#[derive(Debug)]
-pub enum Error {
-    IoError(std::io::Error),
-    ConfigError(serde_yaml::Error),
-}
-
-pub(crate) fn load_config() -> Result<Settings, Error> {
-    let config_str = std::fs::read_to_string("../config/dev.yaml").map_err(|e| Error::IoError(e))?;
-    let config: Settings =
-        serde_yaml::from_str(config_str.as_str()).map_err(|e| Error::ConfigError(e))?;
-    return Ok(config);
-}
-
-lazy_static! {
-    pub static ref CONFIG: Settings = load_config().expect("failed to load config");
-}
+pub(crate) static SETTINGS: Lazy<Settings> =
+    Lazy::new(|| Settings::new().expect("Failed to initialize settings"));
 
 #[derive(Debug, Deserialize, Clone)]
 pub(crate) struct WhisperConfig {
@@ -62,7 +48,7 @@ impl WhisperParams {
         param.set_translate(self.translate);
         param.set_single_segment(false);
         param.set_max_tokens(self.max_tokens as i32);
-        let lang = self.language.as_ref().map(|s| s.as_str());
+        let lang = self.language.as_deref();
         param.set_language(lang);
         let num_cpus = std::thread::available_parallelism()
             .map(|c| c.get())

src/group.rs

@@ -35,7 +35,7 @@ where
                             return Some(will_send);
                         }
                     }
-                    return None;
+                    None
                 };
 
                 let grouped: Vec<I> = select! {

src/lesson.rs

@@ -29,9 +29,9 @@ pub struct LessonsManager {
 
 impl LessonsManager {
     pub(crate) fn new(sdk_config: &SdkConfig) -> Self {
-        let transcript_client = aws_sdk_transcribestreaming::Client::new(&sdk_config);
-        let translate_client = aws_sdk_translate::Client::new(&sdk_config);
-        let polly_client = aws_sdk_polly::Client::new(&sdk_config);
+        let transcript_client = aws_sdk_transcribestreaming::Client::new(sdk_config);
+        let translate_client = aws_sdk_translate::Client::new(sdk_config);
+        let polly_client = aws_sdk_polly::Client::new(sdk_config);
         LessonsManager {
             translate_client,
             polly_client,

src/main.rs

@@ -5,21 +5,23 @@
 
 #![allow(clippy::result_large_err)]
 
-use aws_sdk_transcribestreaming::{meta::PKG_VERSION};
-use futures_util::stream::StreamExt;
-use futures_util::SinkExt;
-use poem::endpoint::{StaticFileEndpoint, StaticFilesEndpoint};
-use poem::web::websocket::{Message, WebSocket};
-use poem::web::{Data, Query};
-use poem::{get, handler, listener::TcpListener, EndpointExt, IntoResponse, Route, Server};
-
-use crate::config::CONFIG;
-use crate::lesson::Viseme;
-use crate::whisper::WhisperHandler;
-use lesson::LessonsManager;
+use aws_sdk_transcribestreaming::meta::PKG_VERSION;
+use futures_util::{stream::StreamExt, SinkExt};
+use poem::{
+    endpoint::{StaticFileEndpoint, StaticFilesEndpoint},
+    get, handler,
+    listener::TcpListener,
+    web::{
+        websocket::{Message, WebSocket},
+        Data, Query,
+    },
+    EndpointExt, IntoResponse, Route, Server,
+};
 use serde::{Deserialize, Serialize};
 use tokio::select;
 
+use crate::{config::*, lesson::*, whisper::*};
+
 mod config;
 mod group;
 mod lesson;
@@ -61,7 +63,7 @@ async fn main() -> Result<(), std::io::Error> {
             StaticFileEndpoint::new("./static/index.html"),
         )
         .data(ctx);
-    let addr = format!("{}:{}", CONFIG.server.host, CONFIG.server.port);
+    let addr = format!("{}:{}", SETTINGS.server.host, SETTINGS.server.port);
     let listener = TcpListener::bind(addr);
     let server = Server::new(listener);
 
@@ -94,7 +96,7 @@ async fn stream_speaker(
         let _origin_tx = lesson.voice_channel();
         let mut transcribe_rx = lesson.transcript_channel();
         let whisper =
-            WhisperHandler::new(CONFIG.whisper.clone(), prompt).expect("failed to create whisper");
+            WhisperHandler::new(SETTINGS.whisper.clone(), prompt).expect("failed to create whisper");
         let mut whisper_transcribe_rx = whisper.subscribe();
         loop {
             select! {

src/whisper.rs

@@ -1,19 +1,23 @@
-use crate::config::{WhisperConfig, CONFIG};
-use crate::group::GroupedWithin;
-use lazy_static::lazy_static;
-use std::collections::VecDeque;
-use std::ffi::c_int;
-use std::fmt::{Debug, Display, Formatter};
-use std::thread::sleep;
-use std::time::Duration;
+use std::{
+    collections::VecDeque,
+    ffi::c_int,
+    fmt::{Debug, Display, Formatter},
+    thread::sleep,
+    time::Duration,
+};
+
+use once_cell::sync::Lazy;
 use tokio::sync::{broadcast, mpsc, oneshot};
 use whisper_rs::{convert_integer_to_float_audio, WhisperContext, WhisperState, WhisperToken};
 use whisper_rs_sys::WHISPER_SAMPLE_RATE;
 
-lazy_static! {
-    static ref WHISPER_CONTEXT: WhisperContext =
-         WhisperContext::new(&*CONFIG.whisper.model).expect("failed to create WhisperContext");
-}
+use crate::config::{Settings, SETTINGS};
+use crate::{config::WhisperConfig, group::GroupedWithin};
+
+static WHISPER_CONTEXT: Lazy<WhisperContext> = Lazy::new(|| {
+    let settings = Settings::new().expect("Failed to initialize settings.");
+    WhisperContext::new(&settings.whisper.model).expect("failed to create WhisperContext")
+});
 
 #[derive(Debug)]
 pub(crate) enum Error {
@@ -86,10 +90,10 @@ impl WhisperHandler {
             .create_state()
             .map_err(|e| Error::whisper_error("failed to create WhisperState", e))?;
         let preset_prompt_tokens = WHISPER_CONTEXT
-            .tokenize(prompt.as_str(), CONFIG.whisper.max_prompt_tokens)
+            .tokenize(prompt.as_str(), SETTINGS.whisper.max_prompt_tokens)
             .map_err(|e| Error::whisper_error("failed to tokenize prompt", e))?;
         tokio::task::spawn_blocking(move || {
-            let mut detector = Detector::new(state, &CONFIG.whisper, preset_prompt_tokens);
+            let mut detector = Detector::new(state, &SETTINGS.whisper, preset_prompt_tokens);
             let mut grouped = GroupedWithin::new(
                 detector.n_samples_step * 2,
                 Duration::from_millis(config.step_ms as u64),
@@ -203,7 +207,7 @@ impl Detector {
             self.preset_prompt_tokens.as_slice(),
             self.prompt_tokens.as_slice(),
         ]
-            .concat();
+        .concat();
         let params = self.config.params.to_full_params(prompt_tokens.as_slice());
         let start = std::time::Instant::now();
         let _ = self
@@ -229,18 +233,18 @@ impl Detector {
         for i in 0..num_segments {
             let end_timestamp: i64 = timestamp_offset
                 + 10 * self
-                .state
-                .full_get_segment_t1(i)
-                .map_err(|e| Error::whisper_error("failed to get end timestamp", e))?;
+                    .state
+                    .full_get_segment_t1(i)
+                    .map_err(|e| Error::whisper_error("failed to get end timestamp", e))?;
             if end_timestamp <= stable_offset {
                 continue;
             }
 
             let start_timestamp: i64 = timestamp_offset
                 + 10 * self
-                .state
-                .full_get_segment_t0(i)
-                .map_err(|e| Error::whisper_error("failed to get start timestamp", e))?;
+                    .state
+                    .full_get_segment_t0(i)
+                    .map_err(|e| Error::whisper_error("failed to get start timestamp", e))?;
             let segment = self
                 .state
                 .full_get_segment_text(i)
@@ -285,12 +289,12 @@ impl Detector {
         let Some(last) = stable_segments.last() else {
             return;
         };
-        let drop_offset: usize = (last.end_timestamp as usize / 1000 * WHISPER_SAMPLE_RATE as usize
-            - self.offset) as usize;
+        let drop_offset: usize =
+            last.end_timestamp as usize / 1000 * WHISPER_SAMPLE_RATE as usize - self.offset;
         let len_to_drain = self.pcm_f32.drain(0..drop_offset).len();
         self.offset += len_to_drain;
 
-        for segment in stable_segments.into_iter() {
+        for segment in stable_segments.iter() {
             self.prompt_tokens.extend(&segment.tokens);
         }
         if self.prompt_tokens.len() > self.config.max_prompt_tokens {
@@ -307,7 +311,7 @@ impl Drop for WhisperHandler {
         let Some(stop_handle) = self.stop_handle.take() else {
             return tracing::warn!("WhisperHandler::drop() called without stop_handle");
         };
-        if let Err(_) = stop_handle.send(()) {
+        if stop_handle.send(()).is_err() {
             tracing::warn!("WhisperHandler::drop() failed to send stop signal");
         }
     }