fix offline pipeline

aic_dataset.py

@@ -1,57 +0,0 @@
-import os
-from huggingface_hub import hf_hub_download
-from constants import DATASET_REPO, MIX_DIR, TRANS_DIR, DATASET_METADATA, HF_TOKEN
-
-
-def _get_base_filenames_from_metadata(metadata_path):
-    local_path = hf_hub_download(
-        repo_id=DATASET_REPO,
-        repo_type="dataset",
-        filename=metadata_path,
-        token=HF_TOKEN
-    )
-    with open(local_path, "r", encoding="utf-8") as f:
-        lines = f.read().splitlines()
-    base_names = []
-    for line in lines[1:]:  # skip header
-        parts = line.split(",")
-        if parts and parts[0]:
-            # Remove directory and extension
-            filename = os.path.splitext(os.path.basename(parts[0]))[0]
-            base_names.append(filename)
-    return base_names
-
-ALL_FILES = _get_base_filenames_from_metadata(DATASET_METADATA)
-
-def get_local_mix_path(file_stem: str) -> str:
-    if not file_stem:
-        return ""
-
-    mix_path = f"{MIX_DIR}/{file_stem}.wav"
-
-    # Download selected files into local cache; returns local filesystem paths
-    mix_local = hf_hub_download(
-        repo_id=DATASET_REPO, repo_type="dataset",
-        filename=mix_path, token=HF_TOKEN
-    )
-
-    return mix_local
-
-def download_transcript(file_stem: str) -> str:
-    """
-    file_stem is the base filename to be downloaded
-    """
-    if not file_stem:
-        return ""
-
-    transcript_path = f"{TRANS_DIR}/{file_stem}.txt"
-
-
-    transcript_text = ""
-    transcript_local = hf_hub_download(
-        repo_id=DATASET_REPO, repo_type="dataset",
-        filename=transcript_path, token=HF_TOKEN
-    )
-    with open(transcript_local, "r", encoding="utf-8", errors="replace") as f:
-        transcript_text = f.read()
-    return transcript_text

app.py

@@ -1,45 +1,20 @@
-import os
-import time
+from random import sample
 
 import gradio as gr
-from loguru import logger
-
-from constants import MINUTES_KEEP
-from aic_dataset import ALL_FILES, get_local_mix_path
-
-from online import transcribe as online_transcribe, clear_ui as online_clear_ui, change_stt_model
-from offline import transcribe_with_original, transcribe_no_original, denoise_audio, cleanup, start_processing
-
-# ===============================
-# Temporary File & Cache Management
-# ===============================
-def cleanup_tmp(minutes_keep: int = MINUTES_KEEP, filter: list[str] = []):
-    skipped = 0
-    removed = 0
-    if os.path.exists("/tmp"):
-        for root, _, files in os.walk("/tmp"):
-            for name in files:
-                f = os.path.join(root, name)
-                is_old = (time.time() - os.path.getmtime(f)) / 60 > minutes_keep
-                filtered = any(filt in f for filt in filter)
-                if filtered or not is_old:
-                    skipped += 1
-                    continue
-                try:
-                    os.remove(f)
-                    removed += 1
-                except Exception as e:
-                    logger.warning(f"Failed to remove file {f}: {e}")
-    logger.info(f"Cleanup tmp complete. Removed {removed} files, skipped {skipped} files.")
-
-
-# ===============================
-# Gradio UI Layout
-# ===============================
-with gr.Blocks() as demo:
-    input_enhancement = gr.State()
-    last_audio_file = gr.State()
+from hf_dataset_utils import ALL_FILES
+
+from online_pipeline import transcribe_stream, reset_streamers, stop_streaming, change_stt_model
+from offline_pipeline import load_file_from_dataset, load_local_file, denoise_audio, retrieve_audio_information
+from clean_up import purge_tmp_directory, cleanup_previous_run
+
 
+
+with gr.Blocks() as demo:
+    sample_stem_dropdown= gr.State("")
+    sample_stem_local = gr.State("")
+    input_array = gr.State()
+    enhanced_array = gr.State()
+    
     gr.HTML(
         '<a href="https://ai-coustics.com/" target="_blank">'
         '<img src="https://mintcdn.com/ai-coustics/Sxcrv8jVSE2qWMR1/logo/dark.svg?fit=max&auto=format&n=Sxcrv8jVSE2qWMR1&q=85&s=7f26caaf21e963912961cbd8541e6d84" '
@@ -66,20 +41,20 @@ with gr.Blocks() as demo:
         # =========================
         # OFFLINE TAB
         # =========================
-        with gr.Tab("Offline", elem_classes="tab-offline"):
+        with gr.Tab("Offline", elem_classes="tab-offline") as offline_tab:
             with gr.Group(elem_classes="panel"):
-                with gr.Tab("Upload", elem_classes="upload-tab"):
-                    audio_file_upload = gr.Audio(type="filepath", sources=["upload", "microphone"])
+                with gr.Tab("Upload", elem_classes="upload-tab") as upload_tab:
+                    audio_file_upload = gr.Audio(type="filepath", sources=["upload"])
                     enhance_btn_for_upload = gr.Button("Enhance", scale=2)
 
-                with gr.Tab("AIC Dataset", elem_classes="dataset-tab"):
+                with gr.Tab("Dawn Chorus", elem_classes="dataset-tab") as dataset_tab:
                     dataset_dropdown = gr.Dropdown(choices=ALL_FILES, label="Choose sample", value=None)
                     audio_file_from_dataset = gr.Audio(type="filepath", interactive=False)
                     enhance_btn_for_dataset = gr.Button("Enhance", scale=2)
 
             with gr.Group(elem_classes="panel results-card", visible=False) as results_card:
                 result_title = gr.Markdown("")
-                enhanced_audio = gr.Audio(type="filepath", interactive=False)
+                enhanced_audio = gr.Audio(type="numpy", interactive=False)
 
                 with gr.Row(equal_height=True, elem_classes="results-row"):
                     with gr.Column(scale=5, min_width=320, elem_classes="results-left"):
@@ -91,48 +66,47 @@ with gr.Blocks() as demo:
                         enhanced_transcript = gr.Textbox(label="Enhanced transcript", lines=3, interactive=False)
                         wer_box = gr.Number(label="Word Error Rate (WER)", interactive=False)
 
-            # Wiring (offline)
-            dataset_dropdown.change(get_local_mix_path, inputs=dataset_dropdown, outputs=[audio_file_from_dataset])
-
+            dataset_dropdown.change(
+                load_file_from_dataset,
+                inputs=dataset_dropdown,
+                outputs=[audio_file_from_dataset, input_array, sample_stem_dropdown]
+            )
+                        
             enhance_btn_for_dataset.click(
-                cleanup,
-                inputs=[input_enhancement, last_audio_file, audio_file_from_dataset],
-                outputs=None,
-            ).then(
-                start_processing,
-                inputs=audio_file_from_dataset,
-                outputs=[input_enhancement, last_audio_file, results_card, result_title],
+                cleanup_previous_run,
+                inputs=[sample_stem_dropdown],
+                outputs=[enhanced_image, noisy_image, enhanced_transcript, original_transcript, wer_box, results_card],
             ).success(
                 denoise_audio,
-                inputs=[input_enhancement, enhancement_level],
-                outputs=[enhanced_audio, enhanced_image, noisy_image],
-            ).then(
-                transcribe_with_original,
-                inputs=[enhanced_audio, dataset_dropdown, stt_model],
-                outputs=[enhanced_transcript, wer_box, original_transcript],
-            ).then(
+                inputs=[input_array, enhancement_level],
+                outputs=[enhanced_array, enhanced_audio],
+            ).success(
+                retrieve_audio_information,
+                inputs=[input_array, enhanced_array, sample_stem_dropdown, stt_model],
+                outputs=[enhanced_image, noisy_image, enhanced_transcript, original_transcript, wer_box],
+            ).success(
                 lambda: gr.update(visible=True),
                 inputs=None,
                 outputs=results_card,
             )
 
             enhance_btn_for_upload.click(
-                cleanup,
-                inputs=[input_enhancement, last_audio_file, audio_file_upload],
-                outputs=None,
+                cleanup_previous_run,
+                inputs=[sample_stem_local],
+                outputs=[enhanced_image, noisy_image, enhanced_transcript, original_transcript, wer_box, results_card],
             ).then(
-                start_processing,
-                inputs=audio_file_upload,
-                outputs=[input_enhancement, last_audio_file, results_card, result_title],
+                load_local_file,
+                inputs=[audio_file_upload],
+                outputs=[input_array, sample_stem_local],
             ).success(
                 denoise_audio,
-                inputs=[input_enhancement, enhancement_level],
-                outputs=[enhanced_audio, enhanced_image, noisy_image],
-            ).then(
-                transcribe_no_original,
-                inputs=[enhanced_audio, stt_model],
-                outputs=[enhanced_transcript, wer_box, original_transcript],
-            ).then(
+                inputs=[input_array, enhancement_level],
+                outputs=[enhanced_array, enhanced_audio],
+            ).success(
+                retrieve_audio_information,
+                inputs=[input_array, enhanced_array, sample_stem_local, stt_model],
+                outputs=[enhanced_image, noisy_image, enhanced_transcript, original_transcript, wer_box],
+            ).success(
                 lambda: gr.update(visible=True),
                 inputs=None,
                 outputs=results_card,
@@ -154,17 +128,23 @@ with gr.Blocks() as demo:
             
 
                 audio_stream.stream(
-                    fn=online_transcribe,
+                    fn=transcribe_stream,
                     inputs=[stream_state, audio_stream, enhancement_level],
                     outputs=[stream_state, enhanced_text, raw_text],
                     stream_every=0.05,
                 )
 
                 clear_btn.click(
-                    fn=online_clear_ui,
+                    fn=reset_streamers,
                     outputs=[stream_state, enhanced_text, raw_text],
                 )
-
-
-cleanup_tmp(minutes_keep=0, filter=[])
+                
+        offline_tab.select(
+            fn=stop_streaming,
+            inputs=None,
+            outputs=[audio_stream, stream_state, enhanced_text, raw_text],
+        )
+        
+
+purge_tmp_directory(max_age_minutes=0, skip_substrings=[])
 demo.launch(allowed_paths=["/tmp", "/"])

clean_up.py

@@ -0,0 +1,101 @@
+import os
+import time
+from loguru import logger
+import gradio as gr
+from typing import Any
+from constants import MINUTES_KEEP
+
+
+def purge_tmp_directory(
+    max_age_minutes: int = MINUTES_KEEP,
+    skip_substrings: list[str] | None = None,
+    tmp_dir: str = "/tmp",
+) -> tuple[int, int]:
+    """
+    Delete files in `tmp_dir` older than `max_age_minutes`, optionally skipping paths
+    that contain any substring in `skip_substrings`.
+
+    Args:
+        max_age_minutes: Files older than this many minutes will be deleted.
+        skip_substrings: If provided, any file path containing one of these substrings
+            will NOT be deleted.
+        tmp_dir: Directory to scan (default: /tmp).
+
+    Returns:
+        (removed, skipped): Number of files removed and skipped.
+    """
+    skip_substrings = skip_substrings or []
+    skipped = 0
+    removed = 0
+
+    if not os.path.exists(tmp_dir):
+        logger.info(f"Temp directory does not exist: {tmp_dir}")
+        return removed, skipped
+
+    now = time.time()
+
+    for root, _, files in os.walk(tmp_dir):
+        for name in files:
+            path = os.path.join(root, name)
+
+            # Skip explicitly excluded paths
+            if any(s in path for s in skip_substrings):
+                skipped += 1
+                continue
+
+            try:
+                age_minutes = (now - os.path.getmtime(path)) / 60.0
+            except Exception as e:
+                logger.warning(f"Could not read mtime for {path}: {e}")
+                skipped += 1
+                continue
+
+            if age_minutes <= max_age_minutes:
+                skipped += 1
+                continue
+
+            try:
+                os.remove(path)
+                removed += 1
+            except Exception as e:
+                logger.warning(f"Failed to remove file {path}: {e}")
+                skipped += 1
+
+    logger.info(f"Temp cleanup complete in {tmp_dir}. Removed {removed} files, skipped {skipped} files.")
+    return removed, skipped
+
+
+def remove_files_related_to(stem: str, tmp_dir: str = "/tmp") -> int:
+    deleted = 0
+
+    if not stem:
+        return 0
+    if not os.path.exists(tmp_dir):
+        return 0
+
+    for root, _, files in os.walk(tmp_dir):
+        for filename in files:
+            if stem not in filename:
+                continue
+            full_path = os.path.join(root, filename)
+            try:
+                os.remove(full_path)
+                deleted += 1
+            except Exception as e:
+                logger.warning(f"Failed to delete file {full_path}: {e}")
+
+    logger.info(f"Deleted {deleted} files in {tmp_dir} related to '{stem}'.")
+    return deleted
+
+
+def cleanup_previous_run(
+    sample_stem: str,
+    tmp_dir: str = "/tmp",
+    max_age_minutes: int = MINUTES_KEEP,
+) -> tuple[None, None, str, str, None, Any]:
+    try:
+        remove_files_related_to(sample_stem, tmp_dir=tmp_dir)
+    except Exception as e:
+        print(f"Failed to delete last run with id {sample_stem}: {e}")
+    purge_tmp_directory(max_age_minutes=max_age_minutes, tmp_dir=tmp_dir)
+    return None, None, "", "", None, gr.update(visible=False)

constants.py

@@ -1,6 +1,8 @@
 from typing import Final
 import os
 
+from stt_streamers.soniox_streamer import SONIOX_WEBSOCKET_URL
+
 CHUNK_SIZE: Final = 1024
 TIMEOUT_FACTOR_MB: Final = 60
 BASE_TIMEOUT_SECONDS: Final = 120
@@ -9,13 +11,12 @@ MODEL_ID: Final = "quail-vf-2.0-l-16khz"
 
 MINUTES_KEEP: Final = 60
 
-DATASET_REPO: Final = "ai-coustics/leo_butch_voice_focus_open_source_en_vad" 
+DATASET_NAME: Final = "ai-coustics/dawn_chorus_en" 
+DEFAULT_SPLIT: Final = "eval"
 MIX_DIR: Final = "mix"
 SPEECH_DIR: Final = "speech"
 TRANS_DIR: Final = "transcripts"
-DATASET_METADATA: Final = "metadata.csv"
 
 # Private access token from Space secrets:
-HF_TOKEN: Final = os.getenv("HF_TOKEN")  # set in HF Space Secrets
+DEFAULT_SR: Final = 16000
 
-DEFAULT_SR: Final = 16000

docs/intro.md

@@ -1,2 +1,9 @@
-This demo showcases **Voice Focus**, our real-time speech enhancement model, combined with **speech-to-text (STT)** transcription.
-Enhance speech, view transcripts instantly, and evaluate recognition quality — either offline or live.
+Welcome! This Space lets you try **ai‑coustics VoiceFocus (Quail Voice Focus)** — a real‑time, STT‑oriented enhancement model that **isolates the foreground speaker** and **suppresses competing voices + background noise**. It’s tuned to keep the phonetic cues speech‑to‑text systems need, so the output isn’t always “prettier” — just cleaner for transcription.
+
+**Offline:** upload an audio file or pick a sample from the dataset, then listen to the enhanced result and compare raw vs enhanced transcripts.
+
+**Online:** stream from your microphone and watch raw vs enhanced text update live.
+
+Use **Enhancement level (0–100)** to dial in the strength, and switch the **STT backend (Deepgram / Soniox)** to see how different engines react to cleaner input.
+
+Tip: speak close to your mic (near‑field) and keep a steady level for best results. Please don’t upload sensitive or private audio—use test material only.

hf_dataset_utils.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+import numpy as np
+from datasets import load_dataset, Audio
+from constants import DATASET_NAME, DEFAULT_SPLIT
+
+# Load once (HF datasets handles caching; HF_TOKEN / login is used automatically if needed)
+ds = load_dataset(DATASET_NAME, split=DEFAULT_SPLIT)
+ds = ds.cast_column("mix", Audio(sampling_rate=16000, decode=True))
+ds = ds.cast_column("speech", Audio(sampling_rate=16000, decode=True))
+
+ALL_FILES = ds["id"]
+
+
+
+def get_audio(sample_id: str, prefix: str) -> tuple[np.ndarray, int]:
+    row = ds.filter(lambda x: x["id"] == sample_id)[0]
+    array = row[f"{prefix}"]["array"]
+    sr = row[f"{prefix}"]["sampling_rate"]
+    np_array = np.array(array, dtype=np.float32)
+    return np_array, sr
+
+
+def get_transcript(sample_id: str) -> str:
+    row = ds.filter(lambda x: x["id"] == sample_id)[0]
+    return row.get("transcript", "")

offline.py

@@ -1,112 +0,0 @@
-import os
-from typing import Optional, Any
-
-import gradio as gr
-from loguru import logger
-
-from sdk import SDKWrapper
-from audio_tools import spec_image
-import shutil
-import tempfile
-from aic_dataset import download_transcript
-from transcribe import transcribe_and_evaluate, transcribe_file
-
-
-def transcribe_with_original(
-    audio_file_path: str,
-    file_stem: str,
-    streamer_type: str = "deepgram",
-) -> tuple[str, Any, Any]:
-    original_transcript = download_transcript(file_stem)
-    transcript, wer = transcribe_and_evaluate(audio_file_path, original_transcript, streamer_type)
-    wer_box = gr.update(value=wer, visible=True)
-    original_transcript_update = gr.update(value=original_transcript, visible=True)
-    return transcript, wer_box, original_transcript_update
-
-
-def transcribe_no_original(audio_file_path: str, stt_model: str = "deepgram") -> tuple[str, Any, Any]:
-    transcript = transcribe_file(audio_file_path, stt_model)
-    hidden = gr.update(visible=False)
-    return transcript, hidden, hidden
-
-
-def create_results_title(path: str) -> str:
-    file_name = os.path.basename(path)
-    return f"## Results for {file_name}" if file_name else "## Results"
-
-
-# ===============================
-# Enhancement (offline)
-# ===============================
-def denoise_audio(
-    sample_path: str,
-    enhancement_level: float = 50.0,
-) -> tuple[Optional[str], Optional[str], Optional[str]]:
-    gr.Info("Processing started. This may take a moment. Please do not refresh or close the window.")
-
-    base, ext = os.path.splitext(sample_path)
-    enhanced_path = f"{base}_enhanced{ext}"
-    noisy_spec_path = f"{base}_noisy_spectrogram.png"
-    enhanced_spec_path = f"{base}_enhanced_spectrogram.png"
-
-    try:
-        sdk = SDKWrapper(os.getenv("SECRET_SDK_KEY"))
-        sdk.init_processor(sample_rate=16000, enhancement_level=float(enhancement_level) / 100.0)
-        sdk.process_file(sample_path, enhanced_path)
-    except Exception as e:
-        gr.Warning(f"{e}")
-        delete_related_files(sample_path)
-        return None, None, None
-
-    spec_image(sample_path).save(noisy_spec_path)
-    spec_image(enhanced_path).save(enhanced_spec_path)
-
-    return enhanced_path, enhanced_spec_path, noisy_spec_path
-
-
-def delete_related_files(path: str):
-    filename_no_ext = os.path.splitext(os.path.basename(path))[0]
-    base_dir = "/tmp"
-    deleted = 0
-    for root, _, files in os.walk(base_dir):
-        for f in files:
-            if filename_no_ext in f:
-                full_path = os.path.join(root, f)
-                try:
-                    os.remove(full_path)
-                    deleted += 1
-                except Exception as e:
-                    logger.warning(f"Failed to delete file {full_path}: {e}")
-    logger.info(f"Deleted {deleted} files related to '{filename_no_ext}'.")
-
-
-def cleanup(last_enhancement: str, last_audio_file: str = "", new_audio_file: str = ""):
-    # delete last uploaded audio if a new one is uploaded
-    if last_audio_file and last_audio_file != new_audio_file and os.path.exists(last_audio_file):
-        try:
-            os.remove(last_audio_file)
-            logger.info(f"Deleted last uploaded audio file: {last_audio_file}")
-        except Exception as e:
-            logger.warning(f"Failed to delete last uploaded audio file {last_audio_file}: {e}")
-
-    if last_enhancement:
-        delete_related_files(last_enhancement)
-
-    cleanup_tmp(minutes_keep=120)
-
-
-def start_processing(sample_path: str) -> tuple[str, str, Any, str]:
-    if not sample_path or not os.path.exists(sample_path):
-        raise ValueError("Missing audio sample. Please upload an audio sample or use the microphone input.")
-
-    if not os.getenv("SECRET_SDK_KEY"):
-        raise ValueError("No SDK key provided. Please contact us at https://ai-coustics.com/contact/.")
-
-    result_title = create_results_title(sample_path)
-
-    ext = os.path.splitext(sample_path)[1]
-    with tempfile.NamedTemporaryFile(delete=False, suffix=ext, dir="/tmp") as tmp_file:
-        shutil.copy(sample_path, tmp_file.name)
-        input_enhancement_path = tmp_file.name
-
-    return input_enhancement_path, sample_path, gr.update(visible=False), result_title

offline_pipeline.py

@@ -0,0 +1,66 @@
+import os
+from typing import Optional, Any
+
+import gradio as gr
+import librosa
+from sdk import SDKWrapper
+from utils import spec_image, compute_wer, transcribe_audio, to_gradio_audio
+import soundfile as sf
+from hf_dataset_utils import get_audio, get_transcript
+from constants import DEFAULT_SR
+import numpy as np  
+
+def retrieve_audio_information(
+    original_array: np.ndarray,
+    enhanced_array: np.ndarray,
+    sample_id: str,
+    stt_model: str,
+) -> tuple[Optional[str], Optional[str], Optional[str], Any, Any]:
+    noisy_spec_path = f"/tmp/{sample_id}_noisy_spectrogram.png"
+    enhanced_spec_path = f"/tmp/{sample_id}_enhanced_spectrogram.png"
+    spec_image(original_array).save(noisy_spec_path)
+    spec_image(enhanced_array).save(enhanced_spec_path)
+    enhanced_transcript = transcribe_audio(enhanced_array, DEFAULT_SR, stt_model, mode="ENHANCED")
+    try: 
+        original_transcript = get_transcript(sample_id)
+        wer = compute_wer(original_transcript, enhanced_transcript)
+    except Exception:
+        original_transcript = "N/A"
+        wer = "N/A"
+    return enhanced_spec_path, noisy_spec_path, enhanced_transcript, original_transcript, wer
+
+
+def denoise_audio(
+    sample_16k: np.ndarray, 
+    enhancement_level: float = 50.0,
+) -> tuple[np.ndarray | None , tuple[int, np.ndarray]| None]:
+    gr.Info("Processing started. This may take a moment. Please do not refresh or close the window.")
+    try:
+        sdk = SDKWrapper()
+        sdk.init_processor(sample_rate=DEFAULT_SR, enhancement_level=float(enhancement_level) / 100.0)
+        enhanced_array = sdk.process_sync(sample_16k)
+    except Exception as e:
+        gr.Warning(f"{e}")
+        raise e
+    gradio_enhanced_audio = to_gradio_audio(enhanced_array, DEFAULT_SR)
+    return enhanced_array, gradio_enhanced_audio
+
+
+def load_local_file(
+    sample_path: str
+    ) -> tuple[np.ndarray, str]:
+    if not sample_path or not os.path.exists(sample_path):
+        gr.Warning("Please upload a valid audio file.")
+        raise ValueError("Missing audio sample. Please upload an audio sample or use the microphone input.")
+    new_sample_stem = os.path.splitext(os.path.basename(sample_path))[0]
+    y_16k, _ = librosa.load(sample_path, sr=DEFAULT_SR, dtype="float32")
+    return y_16k, new_sample_stem
+
+def load_file_from_dataset(sample_id: str) -> tuple[tuple, np.ndarray, str]:
+    if not sample_id:
+        gr.Warning("Please select a sample from the dropdown.")
+        raise ValueError("No sample selected. Please select a sample from the dropdown.")
+    new_sample_stem = sample_id
+    y_16k, sr = get_audio(sample_id, prefix="mix")
+    y_16k_for_gradio = to_gradio_audio(y_16k, sr)# Convert to 16-bit PCM for gradio audio component
+    return y_16k_for_gradio, y_16k, new_sample_stem

requirements.txt

@@ -8,4 +8,6 @@ aic-sdk>=2.0.0
 dotenv
 resampy
 whisper-normalizer
-soxr
+soxr
+datasets
+torchcodec

sdk.py

@@ -7,6 +7,7 @@ import librosa
 import soundfile as sf
 from dotenv import load_dotenv
 import aic_sdk as aic
+import os
 
 from constants import MODEL_ID
 
@@ -14,8 +15,10 @@ load_dotenv()
 
 
 class SDKWrapper:
-    def __init__(self, sdk_key: str, model_id: str = MODEL_ID, models_dir: str = "./models"):
-        self.sdk_key = sdk_key
+    def __init__(self, model_id: str = MODEL_ID, models_dir: str = "./models"):
+        if os.getenv("AIC_SDK_KEY") is None:
+            raise RuntimeError("Missing AIC_SDK_KEY.")
+        self.sdk_key = os.getenv("AIC_SDK_KEY")
         model_path = aic.Model.download(model_id, models_dir)
         self.model = aic.Model.from_file(model_path)
 
@@ -40,41 +43,33 @@ class SDKWrapper:
         self.processor.get_processor_context().set_parameter(
             aic.ProcessorParameter.EnhancementLevel, float(enhancement_level)
         )
-        
-    def process_file(
+    
+    def process_sync(
         self,
-        input_path: str,
-        output_path: str,
-    ) -> None:
+        audio: np.ndarray,
+    ) -> np.ndarray:
         """
-        Offline processing: load file, run fixed-frame processing, save output.
+            audio_array: 2D NumPy array with shape (num_channels, samples) containing audio data to be enhanced
         """
-        audio, _ = librosa.load(input_path, sr=self.processor_sample_rate, mono=True)
-        # audio shape: (n_samples,)
-        audio = audio.astype(np.float32)
-        if not hasattr(self, "processor"):
-            raise ValueError("Processor not initialized")
-        # Planar format expected by SDK: (channels, frames)
-        audio_planar = audio.reshape(1, -1)
-        out = np.zeros_like(audio_planar)
-
+        if len(audio.shape) == 1:
+            audio = audio.reshape(1, -1)
+        if audio.shape[0] > 2 or len(audio.shape) != 2:
+            raise ValueError("Expected audio with shape (n, frames)")
+        out = np.zeros_like(audio)
         chunk_size = self.processor_optimal_frames
-        n = audio_planar.shape[1]
-
+        n = audio.shape[1]
         for i in range(0, n, chunk_size):
-            chunk = audio_planar[:, i : i + chunk_size]
+            chunk = audio[:, i : i + chunk_size]
             if chunk.shape[1] < chunk_size:
                 last = chunk.shape[1]
-                padded = np.zeros((1, chunk_size), dtype=audio_planar.dtype)
+                padded = np.zeros((1, chunk_size), dtype=audio.dtype)
                 padded[:, :last] = chunk
                 enhanced = self.processor.process(padded)
                 out[:, i : i + last] = enhanced[:, :last]
                 break
-
             enhanced = self.processor.process(chunk)
             out[:, i : i + chunk_size] = enhanced[:, :chunk_size]
-
-        sf.write(output_path, out.T, self.processor_sample_rate)
+        return out
     
     def process_chunk(
         self,

stt_streamers/soniox_streamer.py

@@ -44,6 +44,7 @@ class SonioxStreamer:
         # 3. Wait for the 'finished' message from the receive loop
         self.finished_event.wait()
         self.close()
+        print(f"{self.stream_name} streaming complete.")
         with self.lock:
             return self.render_tokens(self.final_tokens, [])
         

transcribe.py

@@ -1,69 +0,0 @@
-from pathlib import Path
-import resampy
-import soundfile as sf
-from stt_streamers import DeepgramStreamer, SonioxStreamer
-from constants import DEFAULT_SR
-from word_error_rate import compute_wer
-
-def transcribe_file(audio_file_path: str, streamer_type: str = "deepgram", mode: str = "RAW"):
-    """
-    Transcribe an audio file using the specified STT streamer.
-
-    Args:
-        streamer_type (str): "soniox" or "deepgram"
-        audio_file_path (str): Path to WAV file
-        mode (str): Optional label for streamer instance ("RAW", "ENHANCED", etc.)
-
-    Returns:
-        str: Transcript text
-    """
-
-    # Validate file
-    audio_path = Path(audio_file_path)
-    if not audio_path.exists():
-        raise FileNotFoundError(f"Audio file not found: {audio_file_path}")
-
-    # Load audio
-    pcm, fs_hz = sf.read(audio_file_path, dtype="float32")
-    if fs_hz != DEFAULT_SR:
-        pcm = resampy.resample(pcm, fs_hz, DEFAULT_SR)
-        fs_hz = DEFAULT_SR
-        
-    # Select streamer
-    api_map = {
-        "soniox": SonioxStreamer,
-        "deepgram": DeepgramStreamer,
-    }
-
-    streamer_key = streamer_type.lower()
-    if streamer_key not in api_map:
-        raise ValueError(
-            f"Invalid streamer_type '{streamer_type}'. "
-            f"Choose from: {', '.join(api_map.keys())}"
-        )
-
-    StreamerClass = api_map[streamer_key]
-    streamer = StreamerClass(fs_hz, mode)
-
-    # Transcribe
-    transcript = streamer.stream_array(pcm)
-
-    return transcript
-
-
-def transcribe_and_evaluate(
-    audio_file_path: str, reference_transcript: str, streamer_type: str = "deepgram"
-) -> tuple[str, float | tuple[float, float, float, float]]:
-    """
-    Transcribe an audio file and compute WER against a reference transcript.
-
-    Args:
-        audio_file_path (str): Path to WAV file
-        reference_transcript (str): Reference transcript for WER calculation
-        streamer_type (str): "soniox" or "deepgram"
-
-    Returns:
-        tuple[str, float]: Transcript text and Word Error Rate (WER)
-    """
-    transcript = transcribe_file(audio_file_path, streamer_type)
-    return transcript, compute_wer(reference_transcript, transcript)

audio_tools.py → utils.py

@@ -1,21 +1,47 @@
 from typing import Optional
+
 import numpy as np
 import librosa
 from PIL import Image
 import io
 import matplotlib.pyplot as plt
+import resampy
+from stt_streamers import DeepgramStreamer, SonioxStreamer
+from constants import DEFAULT_SR
+
+def to_gradio_audio(x: np.ndarray, sr: int) -> tuple[int, np.ndarray]:
+    x = np.asarray(x)
+
+    # Remove extra dims like (1, n, 1) etc.
+    x = np.squeeze(x)
+
+    # If it's (channels, samples), transpose to (samples, channels)
+    if x.ndim == 2 and x.shape[0] in (1, 2) and x.shape[1] > x.shape[0]:
+        x = x.T
+
+    # Ensure mono is (n_samples,)
+    if x.ndim == 2 and x.shape[1] == 1:
+        x = x[:, 0]
+
+    # Return float32 in [-1, 1] (simplest for Gradio)
+    x = x.astype(np.float32)
+    x = np.clip(x, -1.0, 1.0)
+
+    return (sr, x)
+
 
 def spec_image(
-    audio_wav: str,
+    audio_array: np.ndarray,
+    sr: int = DEFAULT_SR,
     n_fft: int = 2048,
     hop_length: int = 512,
     n_mels: int = 128,
     fmax: Optional[float] = None,
 ) -> Image.Image:
     """
-    Generate a mel-spectrogram image from an audio file.
+    Generate a mel-spectrogram image from an audio array.
     """
-    y, sr = librosa.load(audio_wav, mono=True, sr=None)
+    y = audio_array.flatten()  # Ensure it's 1D
     S = librosa.feature.melspectrogram(
         y=y,
         sr=sr,
@@ -65,4 +91,43 @@ def compute_wer(reference: str, hypothesis: str) -> float:
                 d[i - 1][j - 1] + cost,  # Substitution
             )
     wer = d[len(ref_words)][len(hyp_words)] / max(len(ref_words), 1)
-    return wer
+    return wer
+
+
+
+def transcribe_audio(audio_array: np.ndarray, sr: int, streamer_type: str = "Deepgram", mode: str = "RAW"):
+    """
+    Transcribe an audio array using the specified STT streamer.
+
+    Args:
+        audio_array (np.ndarray): Audio data array
+        sr (int): Sample rate of the audio array
+        streamer_type (str): "Soniox" or "Deepgram"
+        mode (str): Optional label for streamer instance ("RAW", "ENHANCED", etc.)
+
+    Returns:
+        str: Transcript text
+    """
+
+    if sr != DEFAULT_SR:
+        audio_array = resampy.resample(audio_array, sr, DEFAULT_SR)
+        sr = DEFAULT_SR
+        
+    api_map = {
+        "Soniox": SonioxStreamer,
+        "Deepgram": DeepgramStreamer,
+    }
+
+    streamer_key = streamer_type
+    if streamer_key not in api_map:
+        raise ValueError(
+            f"Invalid streamer_type '{streamer_type}'. "
+            f"Choose from: {', '.join(api_map.keys())}"
+        )
+
+    StreamerClass = api_map[streamer_key]
+    streamer = StreamerClass(sr, mode)
+
+    transcript = streamer.stream_array(audio_array)
+
+    return transcript

word_error_rate.py

@@ -1,78 +0,0 @@
-import numpy as np
-from whisper_normalizer.english import EnglishTextNormalizer
-
-def tokenize_text(text: str) -> list[str]:
-    """Normalize + tokenize into words."""
-    normalizer = EnglishTextNormalizer()
-    normalized = normalizer(text)
-    # simple whitespace word tokens; adjust if you need punctuation handling
-    return normalized.split()
-
-def compute_wer(y_true: str, y_pred: str, detailed: bool = False)-> float | tuple[float, float, float, float]:
-    """
-    Returns:
-        - if detailed=False: wer
-        - if detailed=True: (wer, ins_rate, del_rate, sub_rate)
-    """
-    ref = tokenize_text(y_true)
-    hyp = tokenize_text(y_pred)
-
-    total_err, ins, dels, subs = levenshtein_word_errors(ref, hyp)
-    ref_len = max(1, len(ref))
-
-    if detailed:
-        return (
-            total_err / ref_len,
-            ins / ref_len,
-            dels / ref_len,
-            subs / ref_len,
-        )
-    return total_err / ref_len
-
-
-def levenshtein_word_errors(reference: list[str], prediction: list[str]):
-    """Edit distance with insertion/deletion/substitution breakdown."""
-    n, m = len(reference), len(prediction)
-
-    # distance + counts
-    d = np.zeros((n + 1, m + 1), dtype=np.int32)
-    ins = np.zeros((n + 1, m + 1), dtype=np.int32)
-    dels = np.zeros((n + 1, m + 1), dtype=np.int32)
-    subs = np.zeros((n + 1, m + 1), dtype=np.int32)
-
-    # init borders
-    for j in range(1, m + 1):
-        d[0, j] = j
-        ins[0, j] = j
-    for i in range(1, n + 1):
-        d[i, 0] = i
-        dels[i, 0] = i
-
-    # DP
-    for i in range(1, n + 1):
-        for j in range(1, m + 1):
-            is_sub = 0 if reference[i - 1] == prediction[j - 1] else 1
-
-            # candidates: delete, insert, substitute/match
-            del_cost = d[i - 1, j] + 1
-            ins_cost = d[i, j - 1] + 1
-            sub_cost = d[i - 1, j - 1] + is_sub
-
-            # choose best (tie-breaking: prefer sub/match, then del, then ins)
-            if sub_cost <= del_cost and sub_cost <= ins_cost:
-                d[i, j] = sub_cost
-                ins[i, j] = ins[i - 1, j - 1]
-                dels[i, j] = dels[i - 1, j - 1]
-                subs[i, j] = subs[i - 1, j - 1] + is_sub
-            elif del_cost <= ins_cost:
-                d[i, j] = del_cost
-                ins[i, j] = ins[i - 1, j]
-                dels[i, j] = dels[i - 1, j] + 1
-                subs[i, j] = subs[i - 1, j]
-            else:
-                d[i, j] = ins_cost
-                ins[i, j] = ins[i, j - 1] + 1
-                dels[i, j] = dels[i, j - 1]
-                subs[i, j] = subs[i, j - 1]
-
-    return int(d[n, m]), int(ins[n, m]), int(dels[n, m]), int(subs[n, m])