Apply cargo fmt formatting across all source files

Signed-off-by: Michael Yuan <michael@secondstate.io>
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: juntao

build.rs

@@ -55,8 +55,8 @@ fn build_mlx() {
     // Ensure CMake and Rust agree on the macOS deployment target.
     // Without this, CMake may compile C++ for macOS 15.x while Rust links
     // for macOS 11.0, causing `___isPlatformVersionAtLeast` linker errors.
-    let deployment_target = std::env::var("MACOSX_DEPLOYMENT_TARGET")
-        .unwrap_or_else(|_| "14.0".to_string());
+    let deployment_target =
+        std::env::var("MACOSX_DEPLOYMENT_TARGET").unwrap_or_else(|_| "14.0".to_string());
 
     // Build mlx-c via CMake (fetches and builds MLX C++ as a dependency)
     let dst = cmake::Config::new(&mlx_c_dir)

src/audio.rs

@@ -71,7 +71,12 @@ pub fn load_audio(path: impl AsRef<Path>, target_sr: usize) -> Result<Vec<f32>>
     }
 
     let probed = symphonia::default::get_probe()
-        .format(&hint, mss, &FormatOptions::default(), &MetadataOptions::default())
+        .format(
+            &hint,
+            mss,
+            &FormatOptions::default(),
+            &MetadataOptions::default(),
+        )
         .context("Unsupported audio format")?;
 
     let mut format = probed.format;
@@ -85,11 +90,7 @@ pub fn load_audio(path: impl AsRef<Path>, target_sr: usize) -> Result<Vec<f32>>
         .codec_params
         .sample_rate
         .context("Unknown sample rate")? as usize;
-    let channels = track
-        .codec_params
-        .channels
-        .map(|c| c.count())
-        .unwrap_or(1);
+    let channels = track.codec_params.channels.map(|c| c.count()).unwrap_or(1);
 
     let track_id = track.id;
     let mut decoder = symphonia::default::get_codecs()
@@ -226,7 +227,13 @@ fn resample(input: &[f32], src_sr: usize, dst_sr: usize) -> Result<Vec<f32>> {
 
 /// Compute mel filterbank matrix: (n_mels, n_fft/2+1).
 /// Follows librosa.filters.mel with norm='slaney'.
-pub fn mel_filterbank(sample_rate: usize, n_fft: usize, n_mels: usize, fmin: f64, fmax: f64) -> Vec<f32> {
+pub fn mel_filterbank(
+    sample_rate: usize,
+    n_fft: usize,
+    n_mels: usize,
+    fmin: f64,
+    fmax: f64,
+) -> Vec<f32> {
     let n_freqs = n_fft / 2 + 1;
 
     let hz_to_mel = |f: f64| -> f64 { 2595.0 * (1.0 + f / 700.0).log10() };

src/bin/server.rs

@@ -257,7 +257,12 @@ async fn transcribe_audio(
         let mut pos = 0;
         while pos < samples.len() {
             let end = (pos + max_samples).min(samples.len());
-            parts.push(transcribe_chunk(&samples[pos..end], &state, &lang, punctuation)?);
+            parts.push(transcribe_chunk(
+                &samples[pos..end],
+                &state,
+                &lang,
+                punctuation,
+            )?);
             if end >= samples.len() {
                 break;
             }
@@ -303,7 +308,10 @@ async fn transcribe_audio(
             );
             (
                 StatusCode::OK,
-                [(axum::http::header::CONTENT_TYPE, "text/plain; charset=utf-8")],
+                [(
+                    axum::http::header::CONTENT_TYPE,
+                    "text/plain; charset=utf-8",
+                )],
                 srt,
             )
                 .into_response()
@@ -421,8 +429,7 @@ fn add_dither(samples: &[f32], dither: f32, seed: u64) -> Vec<f32> {
             .wrapping_mul(6364136223846793005)
             .wrapping_add(1442695040888963407);
         let v = (rng >> 33) as f32 / (u32::MAX as f32);
-        let noise =
-            (-2.0 * u.max(1e-38).ln()).sqrt() * (2.0 * std::f32::consts::PI * v).cos();
+        let noise = (-2.0 * u.max(1e-38).ln()).sqrt() * (2.0 * std::f32::consts::PI * v).cos();
         *s += dither * noise;
     }
     out
@@ -435,7 +442,11 @@ fn add_dither(samples: &[f32], dither: f32, seed: u64) -> Vec<f32> {
 fn load_model(args: &Args) -> Result<ModelState> {
     let model_dir = &args.model_dir;
 
-    anyhow::ensure!(model_dir.exists(), "Model directory not found: {:?}", model_dir);
+    anyhow::ensure!(
+        model_dir.exists(),
+        "Model directory not found: {:?}",
+        model_dir
+    );
     for f in &["config.json", "model.safetensors", "vocab.json"] {
         anyhow::ensure!(
             model_dir.join(f).exists(),

src/decoder.rs

@@ -81,19 +81,18 @@ impl DecoderAttn {
         let (b, t, _) = hidden_states.size3().unwrap();
         let s = source.size()[1];
 
-        let reshape_q = |z: &Tensor| -> Tensor {
-            z.view([b, t, self.n_heads, self.head_dim]).transpose(1, 2)
-        };
+        let reshape_q =
+            |z: &Tensor| -> Tensor { z.view([b, t, self.n_heads, self.head_dim]).transpose(1, 2) };
         let reshape_kv = |z: &Tensor, seq: i64| -> Tensor {
-            z.view([b, seq, self.n_heads, self.head_dim]).transpose(1, 2)
+            z.view([b, seq, self.n_heads, self.head_dim])
+                .transpose(1, 2)
         };
 
         let q = reshape_q(&linear(hidden_states, &self.q_w, &self.q_b));
         let k = reshape_kv(&linear(source, &self.k_w, &self.k_b), s);
         let v = reshape_kv(&linear(source, &self.v_w, &self.v_b), s);
         (q, k, v)
     }
-
 }
 
 // ---------------------------------------------------------------------------
@@ -120,7 +119,11 @@ impl DecoderFFN {
     }
 
     fn forward(&self, x: &Tensor) -> Tensor {
-        linear(&linear(x, &self.dense_in_w, &self.dense_in_b).relu(), &self.dense_out_w, &self.dense_out_b)
+        linear(
+            &linear(x, &self.dense_in_w, &self.dense_in_b).relu(),
+            &self.dense_out_w,
+            &self.dense_out_b,
+        )
     }
 }
 
@@ -187,10 +190,7 @@ impl DecoderLayer {
         let (q_new, k_new, v_new) = self.self_attn.project_qkv(&normed, &normed);
 
         let (k_full, v_full) = match (self_k_cache, self_v_cache) {
-            (Some(kc), Some(vc)) => (
-                Tensor::cat(&[kc, &k_new], 2),
-                Tensor::cat(&[vc, &v_new], 2),
-            ),
+            (Some(kc), Some(vc)) => (Tensor::cat(&[kc, &k_new], 2), Tensor::cat(&[vc, &v_new], 2)),
             _ => (k_new.shallow_clone(), v_new.shallow_clone()),
         };
 
@@ -251,7 +251,7 @@ impl FixedPosEnc {
 // TransformerDecoder (public)
 // ---------------------------------------------------------------------------
 pub struct TransformerDecoder {
-    token_emb: Tensor,           // (vocab, hidden)
+    token_emb: Tensor, // (vocab, hidden)
     pos_enc: FixedPosEnc,
     emb_norm_w: Tensor,
     emb_norm_b: Tensor,
@@ -302,9 +302,7 @@ impl TransformerDecoder {
         let head_w = weights
             .get("log_softmax.mlp.layer0.weight")?
             .shallow_clone();
-        let head_b = weights
-            .get("log_softmax.mlp.layer0.bias")?
-            .shallow_clone();
+        let head_b = weights.get("log_softmax.mlp.layer0.bias")?.shallow_clone();
 
         Ok(Self {
             token_emb,
@@ -356,10 +354,11 @@ impl TransformerDecoder {
     ) -> (Vec<f32>, Vec<(Option<Tensor>, Option<Tensor>)>) {
         let ids = Tensor::from_slice(&[token_id]);
         let emb = self.token_emb.index_select(0, &ids).unsqueeze(0); // (1, 1, hidden)
-        let pe = self.pos_enc.forward(&[position]).unsqueeze(0);      // (1, 1, hidden)
+        let pe = self.pos_enc.forward(&[position]).unsqueeze(0); // (1, 1, hidden)
         let x = layer_norm(&(emb + pe), &self.emb_norm_w, &self.emb_norm_b);
 
-        let mut new_kv: Vec<(Option<Tensor>, Option<Tensor>)> = Vec::with_capacity(self.layers.len());
+        let mut new_kv: Vec<(Option<Tensor>, Option<Tensor>)> =
+            Vec::with_capacity(self.layers.len());
         let mut hidden = x;
 
         for (i, layer) in self.layers.iter().enumerate() {

src/encoder.rs

@@ -68,7 +68,9 @@ struct ConvSubsampling {
 
 impl ConvSubsampling {
     fn load(weights: &Weights, prefix: &str) -> Result<Self> {
-        let w = |n: &str| -> Result<Tensor> { Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone()) };
+        let w = |n: &str| -> Result<Tensor> {
+            Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone())
+        };
         Ok(Self {
             c0_w: w("conv.0.weight")?,
             c0_b: w("conv.0.bias")?,
@@ -169,7 +171,9 @@ struct FeedForward {
 
 impl FeedForward {
     fn load(weights: &Weights, prefix: &str) -> Result<Self> {
-        let w = |n: &str| -> Result<Tensor> { Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone()) };
+        let w = |n: &str| -> Result<Tensor> {
+            Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone())
+        };
         Ok(Self {
             l1_w: w("linear1.weight")?,
             l1_b: w("linear1.bias")?,
@@ -204,7 +208,9 @@ struct ConformerConv {
 
 impl ConformerConv {
     fn load(weights: &Weights, prefix: &str, d_model: i64) -> Result<Self> {
-        let w = |n: &str| -> Result<Tensor> { Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone()) };
+        let w = |n: &str| -> Result<Tensor> {
+            Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone())
+        };
         Ok(Self {
             pw1_w: w("pointwise_conv1.weight")?,
             pw1_b: w("pointwise_conv1.bias")?,
@@ -237,8 +243,14 @@ impl ConformerConv {
 
         // Depthwise conv
         let pad = (kernel_size - 1) / 2;
-        let x =
-            x.conv1d(&self.dw_w, Some(&self.dw_b), &[1], &[pad], &[1], self.d_model);
+        let x = x.conv1d(
+            &self.dw_w,
+            Some(&self.dw_b),
+            &[1],
+            &[pad],
+            &[1],
+            self.d_model,
+        );
 
         // BatchNorm (eval mode)
         let x = batch_norm_eval(&x, &self.bn_w, &self.bn_b, &self.bn_rm, &self.bn_rv);
@@ -277,7 +289,9 @@ struct RelPosAttn {
 impl RelPosAttn {
     fn load(weights: &Weights, prefix: &str, n_heads: i64, d_model: i64) -> Result<Self> {
         let d_k = d_model / n_heads;
-        let w = |n: &str| -> Result<Tensor> { Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone()) };
+        let w = |n: &str| -> Result<Tensor> {
+            Ok(weights.get(&format!("{}{}", prefix, n))?.shallow_clone())
+        };
         Ok(Self {
             q_w: w("linear_q.weight")?,
             q_b: w("linear_q.bias")?,
@@ -309,19 +323,22 @@ impl RelPosAttn {
     fn forward(&self, x: &Tensor, pos_emb: &Tensor) -> Tensor {
         let (b, t, _) = x.size3().unwrap();
 
-        let reshape = |z: &Tensor| -> Tensor {
-            z.view([b, t, self.n_heads, self.d_k]).transpose(1, 2)
-        };
+        let reshape =
+            |z: &Tensor| -> Tensor { z.view([b, t, self.n_heads, self.d_k]).transpose(1, 2) };
 
         let q = reshape(&linear(x, &self.q_w, &self.q_b));
         let k = reshape(&linear(x, &self.k_w, &self.k_b));
         let v = reshape(&linear(x, &self.v_w, &self.v_b));
 
         // pos_emb: (1, 2T-1, d_model) → (1, 2T-1, H, d_k) → (1, H, 2T-1, d_k)
         let n_pos = pos_emb.size()[1];
-        let p = linear(pos_emb, &self.pos_w, &Tensor::zeros(&[1], (Kind::Float, x.device())))
-            .view([1, n_pos, self.n_heads, self.d_k])
-            .transpose(1, 2);
+        let p = linear(
+            pos_emb,
+            &self.pos_w,
+            &Tensor::zeros(&[1], (Kind::Float, x.device())),
+        )
+        .view([1, n_pos, self.n_heads, self.d_k])
+        .transpose(1, 2);
 
         // pos_bias_u/v: (n_heads, d_k) → (1, n_heads, 1, d_k) for broadcasting
         let u = self.pos_bias_u.view([1, self.n_heads, 1, self.d_k]);
@@ -384,11 +401,7 @@ impl ConformerLayer {
                 d_model,
             )?,
             norm_conv: norm("norm_conv")?,
-            conv: ConformerConv::load(
-                weights,
-                &format!("{}conv.", prefix),
-                d_model,
-            )?,
+            conv: ConformerConv::load(weights, &format!("{}conv.", prefix), d_model)?,
             norm_ff2: norm("norm_feed_forward2")?,
             ff2: FeedForward::load(weights, &format!("{}feed_forward2.", prefix))?,
             norm_out: norm("norm_out")?,
@@ -397,13 +410,27 @@ impl ConformerLayer {
 
     fn forward(&self, x: &Tensor, pos_emb: &Tensor) -> Tensor {
         // FF1 (½-scaled)
-        let x = x + 0.5 * self.ff1.forward(&layer_norm(x, &self.norm_ff1.0, &self.norm_ff1.1));
+        let x = x + 0.5
+            * self
+                .ff1
+                .forward(&layer_norm(x, &self.norm_ff1.0, &self.norm_ff1.1));
         // Self-attention
-        let x = &x + self.self_attn.forward(&layer_norm(&x, &self.norm_self_att.0, &self.norm_self_att.1), pos_emb);
+        let x = &x
+            + self.self_attn.forward(
+                &layer_norm(&x, &self.norm_self_att.0, &self.norm_self_att.1),
+                pos_emb,
+            );
         // Conformer conv
-        let x = &x + self.conv.forward(&layer_norm(&x, &self.norm_conv.0, &self.norm_conv.1));
+        let x = &x
+            + self
+                .conv
+                .forward(&layer_norm(&x, &self.norm_conv.0, &self.norm_conv.1));
         // FF2 (½-scaled)
-        let x = &x + 0.5 * self.ff2.forward(&layer_norm(&x, &self.norm_ff2.0, &self.norm_ff2.1));
+        let x = &x
+            + 0.5
+                * self
+                    .ff2
+                    .forward(&layer_norm(&x, &self.norm_ff2.0, &self.norm_ff2.1));
         // Final norm
         layer_norm(&x, &self.norm_out.0, &self.norm_out.1)
     }
@@ -437,15 +464,14 @@ impl ConformerEncoder {
         }
 
         // Encoder→decoder projection (Linear 1280 → 1024)
-        let (enc_dec_proj_w, enc_dec_proj_b) =
-            if let (Ok(w), Ok(b)) = (
-                weights.get("encoder_decoder_proj.weight"),
-                weights.get("encoder_decoder_proj.bias"),
-            ) {
-                (Some(w.shallow_clone()), Some(b.shallow_clone()))
-            } else {
-                (None, None)
-            };
+        let (enc_dec_proj_w, enc_dec_proj_b) = if let (Ok(w), Ok(b)) = (
+            weights.get("encoder_decoder_proj.weight"),
+            weights.get("encoder_decoder_proj.bias"),
+        ) {
+            (Some(w.shallow_clone()), Some(b.shallow_clone()))
+        } else {
+            (None, None)
+        };
 
         Ok(Self {
             pre_encode,

src/inference.rs

@@ -39,8 +39,7 @@ pub fn transcribe(
 
     for (i, &token_id) in prompt.iter().enumerate() {
         let position = i as i64;
-        let (logits, new_kv) =
-            decoder.step(token_id, position, &self_kv_cache, &cross_kv);
+        let (logits, new_kv) = decoder.step(token_id, position, &self_kv_cache, &cross_kv);
         self_kv_cache = new_kv;
         last_logits = logits;
     }
@@ -59,8 +58,7 @@ pub fn transcribe(
         }
         generated.push(next_token);
 
-        let (logits, new_kv) =
-            decoder.step(next_token, position, &self_kv_cache, &cross_kv);
+        let (logits, new_kv) = decoder.step(next_token, position, &self_kv_cache, &cross_kv);
         self_kv_cache = new_kv;
         last_logits = logits;
         position += 1;

src/lib.rs

@@ -8,13 +8,13 @@ pub mod config;
 pub mod tokenizer;
 
 #[cfg(feature = "tch-backend")]
-pub mod weights;
+pub mod decoder;
 #[cfg(feature = "tch-backend")]
 pub mod encoder;
 #[cfg(feature = "tch-backend")]
-pub mod decoder;
-#[cfg(feature = "tch-backend")]
 pub mod inference;
+#[cfg(feature = "tch-backend")]
+pub mod weights;
 
 #[cfg(feature = "mlx")]
 pub mod mlx;