Update dependencies to latest version

Author: jcaden

Cargo.toml

@@ -21,35 +21,35 @@ categories = ["api-bindings", "multimedia::audio"]
 # TODO Investigate which of these dependencies can go behind features.
 bytes = "1"
 futures = "0.3"
-http = "0.2"
+http = "1.3"
 pin-project = "1"
-reqwest = { version = "0.11.22", default-features = false, features = [
+reqwest = { version = "^0.12", default-features = false, features = [
   "json",
   "rustls-tls",
   "stream",
 ] }
-serde = { version = "1.0.215", features = ["derive"] }
+serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1"
 serde_urlencoded = "0.7"
-thiserror = "1"
-tokio = { version = "1.38.0", features = ["full"] }
-tokio-stream = "0.1.15"
-tokio-tungstenite = { version = "0.20.1", features = [
+thiserror = "2"
+tokio = { version = "1.45.1", features = ["full"] }
+tokio-stream = "0.1.17"
+tokio-tungstenite = { version = "0.27.0", features = [
   "rustls-tls-webpki-roots",
 ], optional = true }
-tokio-util = { version = "0.7.1", features = ["codec", "io"] }
-tungstenite = { version = "0.20.1", optional = true }
+tokio-util = { version = "0.7.15", features = ["codec", "io"] }
+tungstenite = { version = "^0.27.0", optional = true }
 url = "2"
 uuid = { version = "1", features = ["serde"] }
 # Dependencies below are specified only to satisfy minimal-versions.
-sha256 = "1.5.0"
-anyhow = "1.0.86"
+sha256 = "1.6.0"
+anyhow = "1.0.98"
 
 [dev-dependencies]
-cpal = "0.13"
+cpal = "^0.16"
 crossbeam = "0.8"
 audio = "0.2.0"
-rodio = { version = "0.17.0" }
+rodio = { version = "0.20" }
 pkg-config = { version = "0.3.30"}
 
 [features]

examples/transcription/websocket/microphone_stream.rs

@@ -3,7 +3,7 @@ use std::thread;
 
 use bytes::{BufMut, Bytes, BytesMut};
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-use cpal::Sample;
+use cpal::{Sample, SampleFormat};
 use crossbeam::channel::RecvError;
 use deepgram::common::options::Encoding;
 use futures::channel::mpsc::{self, Receiver as FuturesReceiver};
@@ -12,6 +12,25 @@ use futures::SinkExt;
 
 use deepgram::{Deepgram, DeepgramError};
 
+macro_rules! create_stream {
+    ($device:ident, $config:expr, $sync_tx:ident, $sample_type:ty) => {
+        $device
+            .build_input_stream(
+                &$config.into(),
+                move |data: &[$sample_type], _: &_| {
+                    let mut bytes = BytesMut::with_capacity(data.len() * 2);
+                    for sample in data {
+                        bytes.put_i16_le(sample.to_sample());
+                    }
+                    $sync_tx.send(bytes.freeze()).unwrap();
+                },
+                |_| panic!(),
+                None,
+            )
+            .unwrap()
+    };
+}
+
 fn microphone_as_stream() -> FuturesReceiver<Result<Bytes, RecvError>> {
     let (sync_tx, sync_rx) = crossbeam::channel::unbounded();
     let (mut async_tx, async_rx) = mpsc::channel(1);
@@ -30,45 +49,12 @@ fn microphone_as_stream() -> FuturesReceiver<Result<Bytes, RecvError>> {
         // dbg!(&config);
 
         let stream = match config.sample_format() {
-            cpal::SampleFormat::F32 => device
-                .build_input_stream(
-                    &config.into(),
-                    move |data: &[f32], _: &_| {
-                        let mut bytes = BytesMut::with_capacity(data.len() * 2);
-                        for sample in data {
-                            bytes.put_i16_le(sample.to_i16());
-                        }
-                        sync_tx.send(bytes.freeze()).unwrap();
-                    },
-                    |_| panic!(),
-                )
-                .unwrap(),
-            cpal::SampleFormat::I16 => device
-                .build_input_stream(
-                    &config.into(),
-                    move |data: &[i16], _: &_| {
-                        let mut bytes = BytesMut::with_capacity(data.len() * 2);
-                        for sample in data {
-                            bytes.put_i16_le(*sample);
-                        }
-                        sync_tx.send(bytes.freeze()).unwrap();
-                    },
-                    |_| panic!(),
-                )
-                .unwrap(),
-            cpal::SampleFormat::U16 => device
-                .build_input_stream(
-                    &config.into(),
-                    move |data: &[u16], _: &_| {
-                        let mut bytes = BytesMut::with_capacity(data.len() * 2);
-                        for sample in data {
-                            bytes.put_i16_le(sample.to_i16());
-                        }
-                        sync_tx.send(bytes.freeze()).unwrap();
-                    },
-                    |_| panic!(),
-                )
-                .unwrap(),
+            SampleFormat::F32 => create_stream!(device, config, sync_tx, f32),
+            SampleFormat::I16 => create_stream!(device, config, sync_tx, i16),
+            SampleFormat::U16 => create_stream!(device, config, sync_tx, u16),
+            sample_format => {
+                panic!("Unsupported sample format: {:?}", sample_format);
+            }
         };
 
         stream.play().unwrap();

src/listen/websocket.rs

@@ -35,6 +35,7 @@ use tokio_tungstenite::{tungstenite::protocol::Message, MaybeTlsStream, WebSocke
 use tungstenite::{
     handshake::client,
     protocol::frame::coding::{Data, OpCode},
+    Utf8Bytes,
 };
 use url::Url;
 use uuid::Uuid;
@@ -517,7 +518,7 @@ async fn run_worker(
                         // eprintln!("<worker> received websocket close");
                         return Err(DeepgramError::WebsocketClose {
                             code: closeframe.code.into(),
-                            reason: closeframe.reason.into_owned(),
+                            reason: closeframe.reason.to_string(),
                         });
                     }
 
@@ -571,13 +572,13 @@ async fn run_worker(
                 if is_open {
                     match message {
                         Some(WsMessage::Audio(audio))=> {
-                            send_message!(ws_stream_send, response_tx, Message::Binary(audio.0));
+                            send_message!(ws_stream_send, response_tx, Message::Binary(Bytes::from(audio.0)));
                             last_sent_message = tokio::time::Instant::now();
 
                         }
                         Some(WsMessage::ControlMessage(msg)) => {
                             send_message!(ws_stream_send, response_tx, Message::Text(
-                                serde_json::to_string(&msg).unwrap_or_default()
+                                Utf8Bytes::from(serde_json::to_string(&msg).unwrap_or_default())
                             ));
                             last_sent_message = tokio::time::Instant::now();
                             if msg == ControlMessage::CloseStream {
@@ -587,7 +588,7 @@ async fn run_worker(
                         None => {
                             // Input stream is shut down.  Keep processing responses.
                             send_message!(ws_stream_send, response_tx, Message::Text(
-                                serde_json::to_string(&ControlMessage::CloseStream).unwrap_or_default()
+                                Utf8Bytes::from(serde_json::to_string(&ControlMessage::CloseStream).unwrap_or_default())
                             ));
                             is_open = false;
                         }
@@ -598,9 +599,9 @@ async fn run_worker(
     }
     // eprintln!("<worker> post loop");
     if let Err(err) = ws_stream_send
-        .send(Message::Text(
+        .send(Message::Text(Utf8Bytes::from(
             serde_json::to_string(&ControlMessage::CloseStream).unwrap_or_default(),
-        ))
+        )))
         .await
     {
         // If the response channel is closed, there's nothing to be done about it now.