deref

Cargo.lock

@@ -104,9 +104,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aws-config"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2bf00cb9416daab4ce4927c54ebe63c08b9caf4d7b9314b6d7a4a2c5a1afb09"
+checksum = "8e245d7c741a8e4b23133f36750c4bcb3938a66ac49510caaf8b83afd52db1ec"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -135,9 +135,9 @@ dependencies = [
 
 [[package]]
 name = "aws-credential-types"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb9073c88dbf12f68ce7d0e149f989627a1d1ae3d2b680459f04ccc29d1cbd0f"
+checksum = "e6dec6f3d42983be70a113f999476185e124884f43f4d60129c7157aede7bda1"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api",
@@ -147,11 +147,10 @@ dependencies = [
 
 [[package]]
 name = "aws-http"
-version = "0.57.2"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24067106d09620cf02d088166cdaedeaca7146d4d499c41b37accecbea11b246"
+checksum = "361c4310fdce94328cc2d1ca0c8a48c13f43009c61d3367585685a50ca8c66b6"
 dependencies = [
- "aws-smithy-http",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
@@ -164,9 +163,9 @@ dependencies = [
 
 [[package]]
 name = "aws-runtime"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6ee0152c06d073602236a4e94a8c52a327d310c1ecd596570ce795af8777ff"
+checksum = "36ba3ad97d674bfaeed684d528a07cee6e81cbf16e6d6c7e272a130b5e71e6b9"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -186,9 +185,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-polly"
-version = "0.36.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1447f6042e2853798f535f3a9e64b3dea089f777ec1442da8ef96644456eb07"
+checksum = "6171a347258d10090d7e6de9c729547f182a47787ba26969571ed1b96a67a461"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -209,9 +208,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-sso"
-version = "0.36.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2eb8158015232b4596ccef74a205600398e152d704b40b7ec9f486092474d7fa"
+checksum = "5786afe1fd164e53f108b2bd4982a31c5a821dc1677d05a12de65ebcc6ede52a"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -231,9 +230,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-ssooidc"
-version = "0.36.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36a1493e1c57f173e53621935bfb5b6217376168dbdb4cd459aebcf645924a48"
+checksum = "31569ac7750ebc3097058c1e72d79576e16b3fb262aa0d6510188bff623f9804"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -253,9 +252,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-sts"
-version = "0.36.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e032b77f5cd1dd3669d777a38ac08cbf8ec68e29460d4ef5d3e50cffa74ec75a"
+checksum = "9b1d955bacd8c3637908a40a4af2f7a732461ee7d95ec02599a3610ee55781d7"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -276,9 +275,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-transcribestreaming"
-version = "0.36.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f2d3625e963f2d453f278d4d8791ca62a055d1e0d1d78e413e6b60308c941f7"
+checksum = "06c279198248d3780d3756c6ff04dec862f48233f162dfa2229684c67232c020"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -301,9 +300,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-translate"
-version = "0.36.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e29d057d3d192013cd1611b9d758c444c981824184514a00543ad8fdf89ef01"
+checksum = "f021251dcd868e9628633e8c8093828aa8828ead1acf5bee6ed77cb3f2cfa268"
 dependencies = [
  "aws-credential-types",
  "aws-http",
@@ -324,14 +323,15 @@ dependencies = [
 
 [[package]]
 name = "aws-sigv4"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f81a6abc4daab06b53cabf27c54189928893283093e37164ca53aa47488a5b"
+checksum = "b4d07e2f2fc32acb7423d054ec8ba2b361dafc95fabc5a211baf4a566571d20e"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-eventstream",
  "aws-smithy-http",
  "aws-smithy-runtime-api",
+ "aws-smithy-types",
  "bytes",
  "form_urlencoded",
  "hex",
@@ -347,9 +347,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-async"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbe53fccd3b10414b9cae63767a15a2789b34e6c6727b6e32b33e8c7998a3e80"
+checksum = "133965d3038e4b79be8ceb7e0ccae2144ddf7b2abff5827d24dc451d559c56b9"
 dependencies = [
  "futures-util",
  "pin-project-lite",
@@ -358,9 +358,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-eventstream"
-version = "0.57.2"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b33fa99f928a5815b94ee07e1377901bcf51aa749034a2c802dc38f9dcfacf5"
+checksum = "1c669e1e5fc0d79561bf7a122b118bd50c898758354fe2c53eb8f2d31507cbc3"
 dependencies = [
  "aws-smithy-types",
  "bytes",
@@ -369,9 +369,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-http"
-version = "0.57.2"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7972373213d1d6e619c0edc9dda2d6634154e4ed75c5e0b2bf065cd5ec9f0d1"
+checksum = "5b1de8aee22f67de467b2e3d0dd0fb30859dc53f579a63bd5381766b987db644"
 dependencies = [
  "aws-smithy-eventstream",
  "aws-smithy-runtime-api",
@@ -390,18 +390,18 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-json"
-version = "0.57.2"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6d64d5af16dd585de9ff6c606423c1aaad47c6baa38de41c2beb32ef21c6645"
+checksum = "6a46dd338dc9576d6a6a5b5a19bd678dcad018ececee11cf28ecd7588bd1a55c"
 dependencies = [
  "aws-smithy-types",
 ]
 
 [[package]]
 name = "aws-smithy-query"
-version = "0.57.2"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7527bf5335154ba1b285479c50b630e44e93d1b4a759eaceb8d0bf9fbc82caa5"
+checksum = "feb5b8c7a86d4b6399169670723b7e6f21a39fc833a30f5c5a2f997608178129"
 dependencies = [
  "aws-smithy-types",
  "urlencoding",
@@ -409,9 +409,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "839b363adf3b2bdab2742a1f540fec23039ea8bc9ec0f9f61df48470cfe5527b"
+checksum = "2dac9354849acb0ce5f64f97321d1ca7703336542630b2e91bd3fcddbf1719a3"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-http",
@@ -433,9 +433,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime-api"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f24ecc446e62c3924539e7c18dec8038dba4fdf8718d5c2de62f9d2fecca8ba9"
+checksum = "f8d85925920c037d30cfdd4cd93680e94c66671fd88083f9a96cb7bb456ef021"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-types",
@@ -449,9 +449,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-types"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "051de910296522a21178a2ea402ea59027eef4b63f1cef04a0be2bb5e25dea03"
+checksum = "91c44684ec45e4ca6f535912885e18e6f7e88c873802cc115a6fb54aebed80f2"
 dependencies = [
  "base64-simd",
  "bytes",
@@ -472,18 +472,18 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-xml"
-version = "0.57.2"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb1e3ac22c652662096c8e37a6f9af80c6f3520cab5610b2fe76c725bce18eac"
+checksum = "0ec40d74a67fd395bc3f6b4ccbdf1543672622d905ef3f979689aea5b730cb95"
 dependencies = [
  "xmlparser",
 ]
 
 [[package]]
 name = "aws-types"
-version = "0.57.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "048bbf1c24cdf4eb1efcdc243388a93a90ebf63979e25fc1c7b8cbd9cb6beb38"
+checksum = "b18c0eb301cce69298555c4884795497c67b3bd511aa3f07470382f4bf3ef043"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-async",
@@ -1565,8 +1565,6 @@ dependencies = [
  "tracing-subscriber",
  "tracing-test",
  "whisper",
- "whisper-rs",
- "whisper-rs-sys",
 ]
 
 [[package]]
@@ -2537,13 +2535,11 @@ name = "whisper"
 version = "0.1.0"
 dependencies = [
  "fvad",
- "hound",
  "lazy_static",
  "once_cell",
  "serde",
  "tokio",
  "tracing",
- "tracing-test",
  "whisper-rs",
  "whisper-rs-sys",
 ]

Cargo.toml

@@ -3,16 +3,13 @@ name = "polyhedron"
 version = "0.1.0"
 edition = "2021"
 
-[workspace]
-members = ["whisper"]
-
 [dependencies]
 anyhow = "1.0"
 async-stream = "0.3"
-aws-config = "0.57.2"
-aws-sdk-transcribestreaming = "0.36.0"
-aws-sdk-translate = "0.36.0"
-aws-sdk-polly = "0.36.0"
+aws-config = "1.0.0"
+aws-sdk-transcribestreaming = "0.39.0"
+aws-sdk-translate = "0.39.0"
+aws-sdk-polly = "0.39.0"
 config = "0.13"
 futures-util = "0.3"
 once_cell = "1.18"
@@ -35,13 +32,6 @@ whisper = ["dep:whisper"]
 version = "1.3"
 features = ["websocket", "static-files"]
 
-[dependencies.whisper-rs]
-git = "https://github.com/mingyang91/whisper-rs.git"
-features = ["coreml", "metal"]
-[dependencies.whisper-rs-sys]
-git = "https://github.com/mingyang91/whisper-rs.git"
-package = "whisper-rs-sys"
-
 [dev-dependencies]
 hound = "3.5.1"
 tracing-test = "*"

src/asr/aws.rs

@@ -1,7 +1,8 @@
 use std::error::Error;
-use std::fmt::{Display, Formatter};
+use std::fmt::{Debug, Display, Formatter};
 use async_stream::stream;
 use async_trait::async_trait;
+use aws_config::SdkConfig;
 use aws_sdk_transcribestreaming::operation::start_stream_transcription::StartStreamTranscriptionOutput;
 use aws_sdk_transcribestreaming::primitives::Blob;
 use aws_sdk_transcribestreaming::types::{
@@ -14,17 +15,21 @@ use futures_util::TryStreamExt;
 use crate::asr::{ASR, Event};
 
 pub struct AWS_ASR {
-    client: aws_sdk_transcribestreaming::Client,
     speaker_voice_channel: tokio::sync::mpsc::Sender<Vec<i16>>,
     speaker_transcript: tokio::sync::broadcast::Sender<Event>,
     drop_handler: Option<tokio::sync::oneshot::Sender<()>>,
 }
 
+impl Debug for AWS_ASR {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "AWS_ASR")
+    }
+}
+
 impl AWS_ASR {
     pub async fn from_env(lang: LanguageCode) -> anyhow::Result<Self> {
         let config = aws_config::load_from_env().await;
         let transcript_client = aws_sdk_transcribestreaming::Client::new(&config);
-        let client = transcript_client.clone();
 
         let (speaker_voice_channel, mut speaker_voice_rx) = tokio::sync::mpsc::channel::<Vec<i16>>(128);
         let (speaker_transcript, _) = tokio::sync::broadcast::channel::<Event>(128);
@@ -70,7 +75,6 @@ impl AWS_ASR {
         });
 
         Ok(Self {
-            client,
             speaker_voice_channel,
             speaker_transcript,
             drop_handler: Some(drop_handler)
@@ -99,8 +103,8 @@ impl Drop for AWS_ASR {
 
 #[async_trait]
 impl ASR for AWS_ASR {
-    async fn frame(&mut self, frame: &[i16]) -> anyhow::Result<()> {
-        Ok(self.speaker_voice_channel.send(frame.to_vec()).await?)
+    async fn frame(&mut self, frame: Vec<i16>) -> anyhow::Result<()> {
+        Ok(self.speaker_voice_channel.send(frame).await?)
     }
 
     fn subscribe(&mut self) -> Receiver<Event> {

src/asr/mod.rs

@@ -1,4 +1,5 @@
-mod aws;
+pub(crate) mod aws;
+#[cfg(feature = "whisper")]
 pub(crate) mod whisper;
 
 use async_trait::async_trait;
@@ -12,6 +13,6 @@ pub(crate) struct Event {
 
 #[async_trait]
 pub(crate) trait ASR {
-    async fn frame(&mut self, frame: &[i16]) -> anyhow::Result<()>;
+    async fn frame(&mut self, frame: Vec<i16>) -> anyhow::Result<()>;
     fn subscribe(&mut self) -> Receiver<Event>;
 }

src/asr/whisper.rs

@@ -1,79 +1,82 @@
-#[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;
+use std::fmt::{Debug, Formatter};
+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;
 
-    extern crate whisper;
+extern crate whisper;
 
-    use whisper::handler::{Error, Output, WhisperHandler, Context};
-    use crate::asr::{ASR, Event};
-    use crate::config::SETTINGS;
+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");
-    }
+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>,
+}
 
-    pub struct Whisper_ASR {
-        whisper: WhisperHandler,
-        tx: tokio::sync::broadcast::Sender<Event>,
+impl Debug for Whisper_ASR {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Whisper_ASR")
     }
+}
 
-    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
-                                        }
+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);
                                 }
+                            },
+                            Err(RecvError::Closed) => break,
+                            Err(RecvError::Lagged(lagged)) => {
+                                tracing::warn!("Whisper ASR output lagged: {}", lagged);
                             }
-                        },
-                    }
+                        }
+                    },
                 }
-            };
-            spawn(fut);
-            Ok(Self { whisper, tx: shared_tx })
-        }
+            }
+        };
+        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?)
-        }
+#[async_trait]
+impl ASR for Whisper_ASR {
+    async fn frame(&mut self, frame: Vec<i16>) -> anyhow::Result<()> {
+        Ok(self.whisper.send_i16(frame).await?)
+    }
 
-        fn subscribe(&mut self) -> Receiver<Event> {
-            self.tx.subscribe()
-        }
+    fn subscribe(&mut self) -> Receiver<Event> {
+        self.tx.subscribe()
     }
 }

src/lesson.rs

@@ -5,35 +5,59 @@ use aws_sdk_transcribestreaming::types::{LanguageCode};
 use futures_util::future::try_join;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
-use std::fmt::{Display};
+use std::fmt::{Debug, Display, Formatter};
 use std::io::BufRead;
+use std::ops::Deref;
 use std::sync::{Arc, Weak};
 use tokio::sync::RwLock;
+use tracing::warn;
 
 use tokio::select;
-use crate::asr::Event;
+use crate::asr::{Event, aws::AWS_ASR, ASR};
 
-#[derive(Clone, Debug)]
-pub struct LessonsManager {
+#[cfg(feature = "whisper")]
+use crate::asr::whisper::Whisper_ASR;
+
+pub struct InnerLessonsManager {
     translate_client: aws_sdk_translate::Client,
     polly_client: aws_sdk_polly::Client,
     lessons: Arc<RwLock<BTreeMap<u32, Lesson>>>,
 }
 
+#[derive(Clone)]
+pub struct LessonsManager {
+    inner: Arc<InnerLessonsManager>,
+}
+
+impl Debug for LessonsManager {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("LessonsManager").finish()
+    }
+}
+
+impl Deref for LessonsManager {
+    type Target = InnerLessonsManager;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
 impl LessonsManager {
     pub(crate) fn new(sdk_config: &SdkConfig) -> Self {
         let translate_client = aws_sdk_translate::Client::new(sdk_config);
         let polly_client = aws_sdk_polly::Client::new(sdk_config);
-        LessonsManager {
+        let inner = InnerLessonsManager {
             translate_client,
             polly_client,
             lessons: Arc::new(RwLock::new(BTreeMap::new())),
-        }
+        };
+        LessonsManager { inner: Arc::new(inner) }
     }
 
     pub(crate) async fn create_lesson(&self, id: u32, speaker_lang: LanguageCode) -> Lesson {
         let mut map = self.lessons.write().await;
-        let lesson: Lesson = InnerLesson::new(self.clone(), speaker_lang).into();
+        let lesson: Lesson = InnerLesson::new(self.clone(), speaker_lang).await.into();
         map.insert(id, lesson.clone());
         lesson
     }
@@ -49,16 +73,24 @@ pub(crate) struct Lesson {
     inner: Arc<InnerLesson>,
 }
 
+impl Deref for Lesson {
+    type Target = InnerLesson;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
 impl Lesson {
     pub(crate) async fn get_or_init(&self, lang: String) -> LangLesson {
         {
-            let map = self.inner.lang_lessons.read().await;
+            let map = self.lang_lessons.read().await;
             if let Some(lang_lesson) = map.get(&lang).and_then(|weak| weak.upgrade()) {
                 return lang_lesson.into();
             }
         }
         {
-            let mut map = self.inner.lang_lessons.write().await;
+            let mut map = self.lang_lessons.write().await;
             if let Some(lang_lesson) = map.get(&lang).and_then(|weak| weak.upgrade()) {
                 lang_lesson.into()
             } else {
@@ -70,11 +102,11 @@ impl Lesson {
     }
 
     pub(crate) async fn send(&self, frame: Vec<i16>) -> anyhow::Result<()> {
-        Ok(self.inner.speaker_voice_channel.send(frame).await?)
+        Ok(self.speaker_voice_channel.send(frame).await?)
     }
 
     pub(crate) fn transcript_channel(&self) -> tokio::sync::broadcast::Receiver<Event> {
-        self.inner.speaker_transcript.subscribe()
+        self.speaker_transcript.subscribe()
     }
 }
 
@@ -87,7 +119,7 @@ impl From<InnerLesson> for Lesson {
 }
 
 #[derive(Debug)]
-struct InnerLesson {
+pub(crate) struct InnerLesson {
     parent: LessonsManager,
     speaker_lang: LanguageCode,
     speaker_voice_channel: tokio::sync::mpsc::Sender<Vec<i16>>,
@@ -97,10 +129,54 @@ struct InnerLesson {
 }
 
 impl InnerLesson {
-    fn new(parent: LessonsManager, speaker_lang: LanguageCode) -> InnerLesson {
+    async fn new(parent: LessonsManager, speaker_lang: LanguageCode) -> InnerLesson {
         let (speaker_transcript, _) = tokio::sync::broadcast::channel::<Event>(128);
-        let (speaker_voice_channel, mut speaker_voice_rx) = tokio::sync::mpsc::channel(128);
+        let (speaker_voice_channel, mut speaker_voice_rx) = tokio::sync::mpsc::channel::<Vec<i16>>(128);
         let (drop_handler, drop_rx) = tokio::sync::oneshot::channel::<Signal>();
+        let mut aws_asr = AWS_ASR::from_env(LanguageCode::EnGb)
+            .await
+            .expect("Failed to initialize AWS ASR");
+        #[cfg(feature = "whisper")]
+        let mut whisper_asr = Whisper_ASR::from_config()
+            .await
+            .expect("Failed to initialize Whisper ASR");
+
+        tokio::spawn(async move {
+            let fut = async {
+                #[cfg(not(feature = "whisper"))]
+                let mut transcribe = aws_asr.subscribe();
+                #[cfg(feature = "whisper")]
+                let mut transcribe = whisper_asr.subscribe();
+                loop {
+                    select! {
+                        msg = speaker_voice_rx.recv() => {
+                            match msg {
+                                Some(frame) => {
+                                    #[cfg(not(feature = "whisper"))]
+                                    let res = aws_asr.frame(frame).await?;
+                                    #[cfg(feature = "whisper")]
+                                    let res = whisper_asr.frame(frame).await?;
+                                },
+                                None => break,
+                            }
+                        },
+                        a = transcribe.recv() => {
+                            todo!()
+                        }
+                    }
+                }
+
+                Ok(()) as anyhow::Result<()>
+            };
+            select! {
+                res = fut => {
+                    if let Err(e) = res {
+                        warn!("Error: {:?}", e);
+                    }
+                }
+                _ = drop_rx => {}
+            }
+        });
 
         InnerLesson {
             parent,
@@ -121,7 +197,7 @@ impl Drop for InnerLesson {
     }
 }
 
-struct InnerLangLesson {
+pub(crate) struct InnerLangLesson {
     parent: Lesson,
     translated_tx: tokio::sync::broadcast::Sender<String>,
     voice_lessons: RwLock<BTreeMap<VoiceId, Weak<InnerVoiceLesson>>>,
@@ -143,7 +219,15 @@ pub(crate) struct LangLesson {
 
 impl LangLesson {
     pub(crate) fn translated_channel(&self) -> tokio::sync::broadcast::Receiver<String> {
-        self.inner.translated_tx.subscribe()
+        self.translated_tx.subscribe()
+    }
+}
+
+impl Deref for LangLesson {
+    type Target = InnerLangLesson;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
     }
 }
 
@@ -164,11 +248,11 @@ impl From<Arc<InnerLangLesson>> for LangLesson {
 impl LangLesson {
     fn new(parent: Lesson, lang: String) -> Self {
         let shared_lang = lang.clone();
-        let shared_speaker_lang = parent.inner.speaker_lang.clone();
+        let shared_speaker_lang = parent.speaker_lang.clone();
         let (translated_tx, _) = tokio::sync::broadcast::channel::<String>(128);
         let shared_translated_tx = translated_tx.clone();
-        let mut transcript_rx = parent.inner.speaker_transcript.subscribe();
-        let translate_client = parent.inner.parent.translate_client.clone();
+        let mut transcript_rx = parent.speaker_transcript.subscribe();
+        let translate_client = parent.parent.translate_client.clone();
         let (drop_handler, drop_rx) = tokio::sync::oneshot::channel::<Signal>();
         tokio::spawn(async move {
             let fut = async {
@@ -212,14 +296,14 @@ impl LangLesson {
 
     pub(crate) async fn get_or_init(&mut self, voice: VoiceId) -> VoiceLesson {
         {
-            let map = self.inner.voice_lessons.read().await;
+            let map = self.voice_lessons.read().await;
             if let Some(voice_lesson) = map.get(&voice).and_then(|weak| weak.upgrade()) {
                 return voice_lesson.into();
             }
         }
 
         {
-            let mut map = self.inner.voice_lessons.write().await;
+            let mut map = self.voice_lessons.write().await;
             if let Some(voice_lesson) = map.get(&voice).and_then(|weak| weak.upgrade()) {
                 voice_lesson.into()
             } else {
@@ -238,11 +322,19 @@ pub(crate) struct VoiceLesson {
 
 impl VoiceLesson {
     pub(crate) fn voice_channel(&self) -> tokio::sync::broadcast::Receiver<Vec<u8>> {
-        self.inner.voice_lesson.subscribe()
+        self.voice_lesson.subscribe()
     }
 
     pub(crate) fn lip_sync_channel(&self) -> tokio::sync::broadcast::Receiver<Vec<Viseme>> {
-        self.inner.lip_sync_tx.subscribe()
+        self.lip_sync_tx.subscribe()
+    }
+}
+
+impl Deref for VoiceLesson {
+    type Target = InnerVoiceLesson;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
     }
 }
 
@@ -260,7 +352,7 @@ impl From<Arc<InnerVoiceLesson>> for VoiceLesson {
     }
 }
 
-struct InnerVoiceLesson {
+pub(crate) struct InnerVoiceLesson {
     lip_sync_tx: tokio::sync::broadcast::Sender<Vec<Viseme>>,
     voice_lesson: tokio::sync::broadcast::Sender<Vec<u8>>,
     drop_handler: Option<tokio::sync::oneshot::Sender<Signal>>,
@@ -275,13 +367,13 @@ impl InnerVoiceLesson {
     fn new(parent: LangLesson, voice: VoiceId) -> InnerVoiceLesson {
         let shared_voice_id: VoiceId = voice.clone();
         let (tx, rx) = tokio::sync::oneshot::channel::<Signal>();
-        let mut translate_rx = parent.inner.translated_tx.subscribe();
+        let mut translate_rx = parent.translated_tx.subscribe();
         let (voice_lesson, _) = tokio::sync::broadcast::channel::<Vec<u8>>(128);
         let shared_voice_lesson = voice_lesson.clone();
         let (lip_sync_tx, _) = tokio::sync::broadcast::channel::<Vec<Viseme>>(128);
         let shared_lip_sync_tx = lip_sync_tx.clone();
-        let client = parent.inner.parent.inner.parent.polly_client.clone();
-        // let lang: LanguageCode = parent.inner.lang.clone().parse().expect("Invalid language code");
+        let client = parent.parent.parent.polly_client.clone();
+        // let lang: LanguageCode = parent.lang.clone().parse().expect("Invalid language code");
         tokio::spawn(async move {
             let fut = async {
                 while let Ok(translated) = translate_rx.recv().await {