split whisper into a standalone crate

Cargo.lock

@@ -1544,6 +1544,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "async-stream",
+ "async-trait",
  "aws-config",
  "aws-sdk-polly",
  "aws-sdk-transcribestreaming",
@@ -1552,6 +1553,7 @@ dependencies = [
  "futures-util",
  "fvad",
  "hound",
+ "lazy_static",
  "once_cell",
  "poem",
  "serde",
@@ -1562,6 +1564,7 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "tracing-test",
+ "whisper",
  "whisper-rs",
  "whisper-rs-sys",
 ]
@@ -2156,9 +2159,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.33.0"
+version = "1.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653"
+checksum = "d0c014766411e834f7af5b8f4cf46257aab4036ca95e9d2c144a10f59ad6f5b9"
 dependencies = [
  "backtrace",
  "bytes",
@@ -2174,9 +2177,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
+checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2529,6 +2532,22 @@ dependencies = [
  "rustix",
 ]
 
+[[package]]
+name = "whisper"
+version = "0.1.0"
+dependencies = [
+ "fvad",
+ "hound",
+ "lazy_static",
+ "once_cell",
+ "serde",
+ "tokio",
+ "tracing",
+ "tracing-test",
+ "whisper-rs",
+ "whisper-rs-sys",
+]
+
 [[package]]
 name = "whisper-rs"
 version = "0.9.0-rc.2"

Cargo.toml

@@ -3,6 +3,9 @@ name = "polyhedron"
 version = "0.1.0"
 edition = "2021"
 
+[workspace]
+members = ["whisper"]
+
 [dependencies]
 anyhow = "1.0"
 async-stream = "0.3"
@@ -21,6 +24,12 @@ tokio-stream = "0.1"
 tracing = { version = "0.1", features = [] }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 fvad = "0.1"
+whisper = { path="whisper", optional = true }
+async-trait = "0.1.74"
+lazy_static = { version = "1.4.0", features = [] }
+
+[features]
+whisper = ["dep:whisper"]
 
 [dependencies.poem]
 version = "1.3"

src/asr/aws.rs

@@ -0,0 +1,17 @@
+use async_trait::async_trait;
+use tokio::sync::broadcast::Receiver;
+use crate::asr::{ASR, Event};
+
+struct AWS_ASR {
+    aws: aws_sdk_transcribestreaming::Client,
+}
+#[async_trait]
+impl ASR for AWS_ASR {
+    async fn frame(&mut self, frame: &[i16]) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    fn subscribe(&mut self) -> Receiver<Event> {
+        todo!()
+    }
+}

src/asr/whisper.rs

@@ -0,0 +1,79 @@
+#[cfg(feature = "whisper")]
+pub mod whisper_asr {
+    use async_trait::async_trait;
+    use tokio::{select, spawn};
+    use tokio::sync::broadcast::Receiver;
+    use tokio::sync::broadcast::error::RecvError;
+    use lazy_static::lazy_static;
+    use whisper::config::WhisperConfig;
+
+    extern crate whisper;
+
+    use whisper::handler::{Error, Output, WhisperHandler, Context};
+    use crate::asr::{ASR, Event};
+    use crate::config::SETTINGS;
+
+    lazy_static! {
+        pub static ref CONTEXT: Context = Context::new(&SETTINGS.whisper.model)
+            .expect("Failed to initialize whisper context");
+    }
+
+    pub struct Whisper_ASR {
+        whisper: WhisperHandler,
+        tx: tokio::sync::broadcast::Sender<Event>,
+    }
+
+    impl Whisper_ASR {
+        pub async fn from_config() -> Result<Whisper_ASR, Error> {
+            let whisper = CONTEXT.create_handler(&SETTINGS.whisper, "".to_string())?;
+            let mut output_rx = whisper.subscribe();
+            let (tx, _) = tokio::sync::broadcast::channel(64);
+            let shared_tx = tx.clone();
+            let fut = async move {
+                loop {
+                    select! {
+                        poll = output_rx.recv() => {
+                            match poll {
+                                Ok(outputs) => {
+                                    for output in outputs {
+                                        let res = match output {
+                                            Output::Stable(segment) => tx.send(Event {
+                                                transcript: segment.text,
+                                                is_final: true,
+                                            }),
+                                            Output::Unstable(segment) => tx.send(Event {
+                                                transcript: segment.text,
+                                                is_final: false,
+                                            }),
+                                        };
+                                        if let Err(e) = res {
+                                            tracing::warn!("Failed to send whisper event: {}", e);
+                                            break
+                                        }
+                                    }
+                                },
+                                Err(RecvError::Closed) => break,
+                                Err(RecvError::Lagged(lagged)) => {
+                                    tracing::warn!("Whisper ASR output lagged: {}", lagged);
+                                }
+                            }
+                        },
+                    }
+                }
+            };
+            spawn(fut);
+            Ok(Self { whisper, tx: shared_tx })
+        }
+    }
+
+    #[async_trait]
+    impl ASR for Whisper_ASR {
+        async fn frame(&mut self, frame: &[i16]) -> anyhow::Result<()> {
+            Ok(self.whisper.send_i16(frame.to_vec()).await?)
+        }
+
+        fn subscribe(&mut self) -> Receiver<Event> {
+            self.tx.subscribe()
+        }
+    }
+}

src/config.rs

@@ -1,106 +1,15 @@
-use std::{env, ffi::c_int, net::IpAddr};
+use std::{env, net::IpAddr};
 
 use config::{Config, Environment, File};
 use once_cell::sync::Lazy;
 use serde::Deserialize;
-use whisper_rs::{FullParams};
 use tracing::debug;
+#[cfg(feature = "whisper")]
+use crate::whisper;
 
 pub(crate) static SETTINGS: Lazy<Settings> =
     Lazy::new(|| Settings::new().expect("Failed to initialize settings"));
 
-#[derive(Debug, Deserialize, Clone)]
-pub(crate) struct WhisperConfig {
-    pub(crate) params: WhisperParams,
-    pub(crate) step_ms: usize,
-    pub(crate) length_ms: usize,
-    pub(crate) keep_ms: usize,
-    pub(crate) model: String,
-    pub(crate) max_prompt_tokens: usize,
-    pub(crate) context_confidence_threshold: f32,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize, Clone)]
-pub(crate) struct WhisperParams {
-    pub(crate) n_threads: Option<usize>,
-    pub(crate) max_tokens: Option<u32>,
-    pub(crate) audio_ctx: Option<u32>,
-    pub(crate) speed_up: Option<bool>,
-    pub(crate) translate: Option<bool>,
-    pub(crate) no_context: Option<bool>,
-    pub(crate) print_special: Option<bool>,
-    pub(crate) print_realtime: Option<bool>,
-    pub(crate) print_progress: Option<bool>,
-    pub(crate) token_timestamps: Option<bool>,
-    pub(crate) no_timestamps: Option<bool>,
-    pub(crate) temperature_inc: Option<f32>,
-    pub(crate) entropy_threshold: Option<f32>,
-    pub(crate) single_segment: Option<bool>,
-    pub(crate) suppress_non_speech_tokens: Option<bool>,
-    pub(crate) n_max_text_ctx: Option<usize>,
-    // pub(crate) tinydiarize: bool,
-    pub(crate) language: Option<String>,
-}
-
-impl WhisperParams {
-    pub(crate) fn to_full_params<'a, 'b>(&'a self, tokens: &'b [c_int]) -> FullParams<'a, 'b> {
-        let mut param = FullParams::new(Default::default());
-        if let Some(print_progress) = self.print_progress.as_ref() {
-            param.set_print_progress(*print_progress);
-        }
-        if let Some(print_special) = self.print_special.as_ref() {
-            param.set_print_special(*print_special);
-        }
-        if let Some(print_realtime) = self.print_realtime.as_ref() {
-            param.set_print_realtime(*print_realtime);
-        }
-        if let Some(single_segment) = self.single_segment.as_ref() {
-            param.set_single_segment(*single_segment);
-        }
-        if let Some(no_timestamps) = self.no_timestamps.as_ref() {
-            param.set_print_timestamps(!no_timestamps);
-        }
-        if let Some(token_timestamps) = self.token_timestamps.as_ref() {
-            param.set_token_timestamps(*token_timestamps);
-        }
-        if let Some(translate) = self.translate.as_ref() {
-            param.set_translate(*translate);
-        }
-        if let Some(max_tokens) = self.max_tokens.as_ref() {
-            param.set_max_tokens(*max_tokens as i32);
-        }
-        param.set_language(self.language.as_deref());
-        if let Some(n_threads) = self.n_threads.as_ref() {
-            param.set_n_threads(*n_threads as i32);
-        }
-        if let Some(audio_ctx) = self.audio_ctx.as_ref() {
-            param.set_audio_ctx(*audio_ctx as i32);
-        }
-        if let Some(speed_up) = self.speed_up.as_ref() {
-            param.set_speed_up(*speed_up);
-        }
-        // param.set_tdrz_enable(self.tinydiarize);
-        if let Some(temperature_inc) = self.temperature_inc.as_ref() {
-            param.set_temperature_inc(*temperature_inc);
-        }
-        if let Some(suppress_non_speech_tokens) = self.suppress_non_speech_tokens.as_ref() {
-            param.set_suppress_non_speech_tokens(*suppress_non_speech_tokens);
-        }
-        if let Some(no_context) = self.no_context.as_ref() {
-            param.set_no_context(*no_context);
-        }
-        if let Some(entropy_threshold) = self.entropy_threshold.as_ref() {
-            param.set_entropy_thold(*entropy_threshold);
-        }
-        if let Some(n_max_text_ctx) = self.n_max_text_ctx.as_ref() {
-            param.set_n_max_text_ctx(*n_max_text_ctx as i32);
-        }
-
-        param.set_tokens(tokens);
-        param
-    }
-}
 
 #[derive(Debug, Deserialize)]
 pub(crate) struct Server {
@@ -110,7 +19,8 @@ pub(crate) struct Server {
 
 #[derive(Debug, Deserialize)]
 pub struct Settings {
-    pub(crate) whisper: WhisperConfig,
+    #[cfg(feature = "whisper")]
+    pub(crate) whisper: whisper::config::WhisperConfig,
     pub(crate) server: Server,
 }
 

src/main.rs

@@ -5,6 +5,8 @@
 
 #![allow(clippy::result_large_err)]
 
+#[cfg(feature = "whisper")]
+extern crate whisper;
 use aws_sdk_transcribestreaming::meta::PKG_VERSION;
 use futures_util::{stream::StreamExt, SinkExt};
 use poem::{
@@ -22,12 +24,13 @@ use tokio::select;
 use tracing::debug;
 use tracing_subscriber::{fmt, prelude::*, EnvFilter};
 
-use crate::{config::*, lesson::*, whisper::*};
+use crate::{config::*, lesson::*};
+#[cfg(feature = "whisper")]
+use crate::whisper::*;
 
 mod config;
-mod group;
 mod lesson;
-mod whisper;
+mod asr;
 
 #[derive(Clone)]
 struct Context {
@@ -104,20 +107,23 @@ async fn stream_speaker(
     ws.on_upgrade(|mut socket| async move {
         let _origin_tx = lesson.voice_channel();
         let mut transcribe_rx = lesson.transcript_channel();
-        let mut whisper = WhisperHandler::new(SETTINGS.whisper.clone(), prompt)
+        #[cfg(feature = "whisper")]
+        let mut whisper = asr::whisper::whisper_asr::CONTEXT.create_handler(&SETTINGS.whisper, prompt)
             .expect("failed to create whisper");
+        #[cfg(feature = "whisper")]
         let mut whisper_transcribe_rx = whisper.subscribe();
         loop {
             select! {
-                w = whisper_transcribe_rx.recv() => {
-                    let Ok(_txt) = w else {
-                        // TODO: handle msg
-                        continue
-                    };
-                }
+                // w = whisper_transcribe_rx.recv() => {
+                //     let Ok(_txt) = w else {
+                //         // TODO: handle msg
+                //         continue
+                //     };
+                // }
                 msg = socket.next() => {
                     match msg.as_ref() {
                         Some(Ok(Message::Binary(bin))) => {
+                            #[cfg(feature = "whisper")]
                             let _ = whisper.send_bytes(bin.to_vec()).await; // whisper test
                             // if let Err(e) = origin_tx.send(bin.to_vec()).await {
                             //     tracing::warn!("failed to send voice: {}", e);

whisper/src/config.rs

@@ -0,0 +1,95 @@
+use serde::Deserialize;
+use whisper_rs::{FullParams, WhisperToken};
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct WhisperConfig {
+    pub(crate) params: WhisperParams,
+    pub(crate) step_ms: usize,
+    pub(crate) length_ms: usize,
+    pub(crate) keep_ms: usize,
+    pub model: String,
+    pub(crate) max_prompt_tokens: usize,
+    pub(crate) context_confidence_threshold: f32,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize, Clone)]
+pub(crate) struct WhisperParams {
+    pub(crate) n_threads: Option<usize>,
+    pub(crate) max_tokens: Option<u32>,
+    pub(crate) audio_ctx: Option<u32>,
+    pub(crate) speed_up: Option<bool>,
+    pub(crate) translate: Option<bool>,
+    pub(crate) no_context: Option<bool>,
+    pub(crate) print_special: Option<bool>,
+    pub(crate) print_realtime: Option<bool>,
+    pub(crate) print_progress: Option<bool>,
+    pub(crate) token_timestamps: Option<bool>,
+    pub(crate) no_timestamps: Option<bool>,
+    pub(crate) temperature_inc: Option<f32>,
+    pub(crate) entropy_threshold: Option<f32>,
+    pub(crate) single_segment: Option<bool>,
+    pub(crate) suppress_non_speech_tokens: Option<bool>,
+    pub(crate) n_max_text_ctx: Option<usize>,
+    // pub(crate) tinydiarize: bool,
+    pub(crate) language: Option<String>,
+}
+
+impl WhisperParams {
+    pub(crate) fn to_full_params<'a, 'b>(&'a self, tokens: &'b [WhisperToken]) -> FullParams<'a, 'b> {
+        let mut param = FullParams::new(Default::default());
+        if let Some(print_progress) = self.print_progress.as_ref() {
+            param.set_print_progress(*print_progress);
+        }
+        if let Some(print_special) = self.print_special.as_ref() {
+            param.set_print_special(*print_special);
+        }
+        if let Some(print_realtime) = self.print_realtime.as_ref() {
+            param.set_print_realtime(*print_realtime);
+        }
+        if let Some(single_segment) = self.single_segment.as_ref() {
+            param.set_single_segment(*single_segment);
+        }
+        if let Some(no_timestamps) = self.no_timestamps.as_ref() {
+            param.set_print_timestamps(!no_timestamps);
+        }
+        if let Some(token_timestamps) = self.token_timestamps.as_ref() {
+            param.set_token_timestamps(*token_timestamps);
+        }
+        if let Some(translate) = self.translate.as_ref() {
+            param.set_translate(*translate);
+        }
+        if let Some(max_tokens) = self.max_tokens.as_ref() {
+            param.set_max_tokens(*max_tokens as i32);
+        }
+        param.set_language(self.language.as_deref());
+        if let Some(n_threads) = self.n_threads.as_ref() {
+            param.set_n_threads(*n_threads as i32);
+        }
+        if let Some(audio_ctx) = self.audio_ctx.as_ref() {
+            param.set_audio_ctx(*audio_ctx as i32);
+        }
+        if let Some(speed_up) = self.speed_up.as_ref() {
+            param.set_speed_up(*speed_up);
+        }
+        // param.set_tdrz_enable(self.tinydiarize);
+        if let Some(temperature_inc) = self.temperature_inc.as_ref() {
+            param.set_temperature_inc(*temperature_inc);
+        }
+        if let Some(suppress_non_speech_tokens) = self.suppress_non_speech_tokens.as_ref() {
+            param.set_suppress_non_speech_tokens(*suppress_non_speech_tokens);
+        }
+        if let Some(no_context) = self.no_context.as_ref() {
+            param.set_no_context(*no_context);
+        }
+        if let Some(entropy_threshold) = self.entropy_threshold.as_ref() {
+            param.set_entropy_thold(*entropy_threshold);
+        }
+        if let Some(n_max_text_ctx) = self.n_max_text_ctx.as_ref() {
+            param.set_n_max_text_ctx(*n_max_text_ctx as i32);
+        }
+
+        param.set_tokens(tokens);
+        param
+    }
+}

src/whisper.rs → whisper/src/handler.rs

@@ -6,35 +6,47 @@ use std::{
 };
 use fvad::SampleRate;
 
-use once_cell::sync::Lazy;
-use tokio::sync::{broadcast, mpsc, oneshot};
+use tokio::sync::{broadcast, mpsc, oneshot, OnceCell};
 use tokio::time::Instant;
-use tracing::{debug, trace, warn};
-use whisper_rs::{convert_integer_to_float_audio, WhisperContext, WhisperState, WhisperToken, WhisperTokenData};
+use tracing::{warn};
+use whisper_rs::{convert_integer_to_float_audio, WhisperContext, WhisperError, WhisperState, WhisperToken, WhisperTokenData};
 
-use crate::config::{Settings, SETTINGS};
 use crate::{config::WhisperConfig, group::GroupedWithin};
 
 const WHISPER_SAMPLE_RATE: usize = whisper_rs_sys::WHISPER_SAMPLE_RATE as usize;
 
-static WHISPER_CONTEXT: Lazy<WhisperContext> = Lazy::new(|| {
-    let settings = Settings::new().expect("Failed to initialize settings.");
-    if tracing::enabled!(tracing::Level::DEBUG) {
-        let info = whisper_rs::print_system_info();
-        debug!("system_info: n_threads = {} / {} | {}\n",
-            settings.whisper.params.n_threads.unwrap_or(0),
-            std::thread::available_parallelism().map(|c| c.get()).unwrap_or(0),
-            info);
+pub struct Context {
+    context: WhisperContext,
+}
+
+impl <'a> Context {
+    pub fn new(model: &str) -> Result<Context, WhisperError> {
+        WhisperContext::new(model)
+            .map(|context| Self { context })
+    }
+
+    pub fn create_handler(&'static self, config: &'static WhisperConfig, prompt: String) -> Result<WhisperHandler, Error> {
+        WhisperHandler::new(&self.context, config, prompt)
     }
-    WhisperContext::new(&settings.whisper.model).expect("failed to create WhisperContext")
-});
+}
+
+static WHISPER_CONTEXT: OnceCell<WhisperContext> = OnceCell::const_new();
 
+async fn initialize_whisper_context(model: String) -> WhisperContext {
+    tokio::task::spawn_blocking(move || {
+        WhisperContext::new(&model).expect("failed to create WhisperContext")
+    }).await.expect("failed to spawn")
+}
+
+async fn get_whisper_context(model: String) -> &'static WhisperContext {
+    WHISPER_CONTEXT.get_or_init(|| initialize_whisper_context(model)).await
+}
 
 #[derive(Debug)]
-pub(crate) enum Error {
+pub enum Error {
     WhisperError {
         description: String,
-        error: whisper_rs::WhisperError,
+        error: WhisperError,
     },
 }
 
@@ -97,22 +109,25 @@ pub struct WhisperHandler {
 }
 
 impl WhisperHandler {
-    pub(crate) fn new(config: WhisperConfig, prompt: String) -> Result<Self, Error> {
+
+    fn new(whisper_context: &'static WhisperContext, config: &'static WhisperConfig, prompt: String) -> Result<Self, Error> {
+        // let whisper_context = get_whisper_context(config.model.clone()).await;
+        let state = whisper_context
+            .create_state()
+            .map_err(|e| Error::whisper_error("failed to create WhisperState", e))?;
+        let preset_prompt_tokens = whisper_context
+            .tokenize(&prompt, config.max_prompt_tokens)
+            .map_err(|e| Error::whisper_error("failed to tokenize prompt", e))?;
         let vad_slice_size = WHISPER_SAMPLE_RATE / 100 * 3;
         let (stop_handle, mut stop_signal) = oneshot::channel();
         let (pcm_tx, pcm_rx) = mpsc::channel::<Vec<i16>>(128);
         let (transcription_tx, _) = broadcast::channel::<Vec<Output>>(128);
         let shared_transcription_tx = transcription_tx.clone();
-        let state = WHISPER_CONTEXT
-            .create_state()
-            .map_err(|e| Error::whisper_error("failed to create WhisperState", e))?;
-        let preset_prompt_tokens = WHISPER_CONTEXT
-            .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 vad = fvad::Fvad::new().expect("failed to create VAD")
                 .set_sample_rate(SampleRate::Rate16kHz);
-            let mut detector = Detector::new(state, &SETTINGS.whisper, preset_prompt_tokens);
+            let mut detector = Detector::new(state, &config, preset_prompt_tokens);
             let mut grouped = GroupedWithin::new(
                 detector.n_samples_step,
                 Duration::from_millis(config.step_ms as u64),
@@ -368,7 +383,9 @@ mod test {
     use std::io::{stdout, Write};
     use hound;
     use tracing_test;
-    use tracing::info;
+    use tracing::{info, debug};
+    use crate::config::WhisperParams;
+    use lazy_static::lazy_static;
 
     async fn print_output(output: Output) {
         match output {
@@ -386,18 +403,50 @@ mod test {
         }
         stdout().flush().unwrap();
     }
+
+    lazy_static! {
+        static ref CONFIG: WhisperConfig = WhisperConfig {
+            length_ms: 5000,
+            step_ms: 500,
+            keep_ms: 200,
+            model: "models/ggml-large-v3.bin".to_string(),
+            max_prompt_tokens: 32,
+            context_confidence_threshold: 0.5,
+            params: WhisperParams {
+                n_threads: None,
+                max_tokens: None,
+                audio_ctx: None,
+                speed_up: None,
+                translate: None,
+                no_context: None,
+                print_special: None,
+                print_realtime: None,
+                print_progress: None,
+                token_timestamps: None,
+                no_timestamps: None,
+                temperature_inc: None,
+                entropy_threshold: None,
+                single_segment: Some(true),
+                suppress_non_speech_tokens: None,
+                n_max_text_ctx: None,
+                language: Some("en".to_string()),
+            }
+        };
+
+        static ref CONTEXT: Context = Context::new(&CONFIG.model).expect("failed to create WhisperContext");
+    }
+
     #[tokio::test]
     #[tracing_test::traced_test]
     async fn test_whisper_handler() {
-        let mut whisper_handler = WhisperHandler::new(
-            SETTINGS.whisper.clone(),
-            "Harry Potter and the Philosopher's Stone".to_string(),
-        ).expect("failed to create WhisperHandler");
+        let mut whisper_handler = CONTEXT
+            .create_handler(&CONFIG, "Harry Potter and the Philosopher's Stone".to_string())
+            .expect("failed to create WhisperHandler");
 
         let wav = hound::WavReader::open("samples/ADHD_1A.wav")
             .expect("failed to open wav");
         let spec = wav.spec();
-        println!("{:?}", spec);
+        info!("{:?}", spec);
         let samples = wav
             .into_samples::<i16>()
             .map(|s| s.unwrap())
@@ -423,9 +472,9 @@ mod test {
 
                 match output {
                     Output::Stable(stable) => {
-                        println!("{}", stable.text);
+                        debug!("{}", stable.text);
                     },
-                    Output::Unstable(unstable) => {
+                    Output::Unstable(_unstable) => {
 
                     }
                 }

whisper/src/main.rs

@@ -0,0 +1,6 @@
+
+
+#[tokio::main]
+async fn main() {
+
+}