impl walkthrough

.gitignore

@@ -2,4 +2,4 @@
 .vscode/settings.json
 app/__pycache__/
 __pycache__/
-logs/app.log
+logs/

app.py

@@ -1,222 +1,309 @@
-from app.logger_config import logger as logging
+from app.logger_config import (
+    logger as logging,
+    DEBUG
+) 
 import numpy as np
 import gradio as gr
 import asyncio
 from fastrtc.webrtc import WebRTC
+from fastrtc.utils import AdditionalOutputs
 from pydub import AudioSegment
 import time
-import os 
+import os
 from gradio.utils import get_space
 
-from app.logger_config import logger as logging
 from app.utils import (
-    generate_coturn_config
+    generate_coturn_config,
+    raise_function
 )
+from app.session_utils import (
+    on_load,
+    on_unload,
+    get_active_sessions,
+    register_session,
+    reset_all_active_sessions,
+)
+
+from app.ui_utils import (
+    SUPPORTED_LANGS_MAP,
+    EXAMPLE_CONFIGS,
+    apply_preset_if_example,
+    reset_to_defaults,
+    summarize_config,
+    handle_additional_outputs,
+    get_custom_theme,
+    on_file_load
+)
+
+from app.stream_utils import (
+    read_and_stream_audio,
+    stop_streaming
+)
+
+# --------------------------------------------------------
+# Initialization
+# --------------------------------------------------------
+reset_all_active_sessions()
 
-EXAMPLE_FILES = ["data/bonjour.wav", "data/bonjour2.wav"]
-DEFAULT_FILE = EXAMPLE_FILES[0] 
-# Utilisé pour signaler l'arrêt du streaming à l'intérieur du générateur
-stop_stream_state = gr.State(value=False)
-
-def read_and_stream_audio(filepath_to_stream: str):
-    """
-    Un générateur synchrone qui lit un fichier audio (via filepath_to_stream)
-    et le streame chunk par chunk d'1 seconde.
-    """
-    
-    if not filepath_to_stream or not os.path.exists(filepath_to_stream):
-        logging.error(f"Fichier audio non trouvé ou non spécifié : {filepath_to_stream}")
-        # Tenter d'utiliser le fichier par défaut en cas de problème
-        if os.path.exists(DEFAULT_FILE):
-            logging.warning(f"Utilisation du fichier par défaut : {DEFAULT_FILE}")
-            filepath_to_stream = DEFAULT_FILE
-        else:
-            logging.error("Fichier par défaut non trouvé. Arrêt du stream.")
-            return
-
-    logging.info(f"Préparation du segment audio depuis : {filepath_to_stream}")
-    # Réinitialiser le signal d'arrêt à chaque lancement
-    stop_stream_state.value = False
-    
-    try:
-        segment = AudioSegment.from_file(filepath_to_stream)
-        chunk_duree_ms = 1000
-        logging.info(f"Début du streaming en chunks de {chunk_duree_ms}ms...")
-
-        for i, chunk in enumerate(segment[::chunk_duree_ms]):
-            iter_start_time = time.perf_counter()
-            logging.info(f"Envoi du chunk {i+1}...")
-
-            if stop_stream_state.value:
-                logging.info("Signal d'arrêt reçu, arrêt de la boucle.")
-                break
-
-            output_chunk = (
-                chunk.frame_rate,
-                np.array(chunk.get_array_of_samples()).reshape(1, -1),
+theme,css_style = get_custom_theme()
+
+with gr.Blocks(theme=theme, css=css_style) as demo:
+    session_hash = gr.State()
+    session_hash_box = gr.Textbox(label="Session ID", interactive=False, visible=DEBUG)
+    with gr.Accordion("📊 Active Sessions", open=True ,visible=DEBUG):
+        sessions_table = gr.DataFrame(
+            headers=["session_hash", "file", "start_time", "status"],
+            interactive=False,
+            wrap=True,
+            max_height=200,
+        )
+        gr.Timer(3.0).tick(fn=get_active_sessions, outputs=sessions_table)
+
+    demo.load(fn=on_load, inputs=None, outputs=[session_hash, session_hash_box])
+    demo.unload(on_unload)
+    stop_streaming_flags = gr.State(value={"stop": False})
+    active_filepath = gr.State(value=next(iter(EXAMPLE_CONFIGS)))
+
+    with gr.Walkthrough(selected=0) as walkthrough:
+        # === STEP 1 ===
+        with gr.Step("Audio", id=0) as audio_source_step:
+            gr.Markdown(
+                """
+                ### Step 1: Upload or Record an Audio File
+                You can upload an existing file or record directly from your microphone.  
+                Accepted formats: **.wav**, **.mp3**, **.flac**  
+                Maximum length recommended: **60 seconds**
+                """
             )
 
-            yield output_chunk
-
-            iter_end_time = time.perf_counter()
-            processing_duration_ms = (iter_end_time - iter_start_time) * 1000
-            
-            sleep_duration = (chunk_duree_ms / 1000.0) - (processing_duration_ms / 1000.0) - 0.1
-            if sleep_duration < 0:
-                sleep_duration = 0.01 # Éviter un temps de sommeil négatif
-                
-            logging.debug(f"Temps de traitement: {processing_duration_ms:.2f}ms, Sommeil: {sleep_duration:.2f}s")
-
-            elapsed = 0.0
-            interval = 0.05
-            while elapsed < sleep_duration:
-                if stop_stream_state.value:
-                    logging.info("Signal d'arrêt reçu pendant l'attente.")
-                    break
-                wait_chunk = min(interval, sleep_duration - elapsed)
-                time.sleep(wait_chunk)
-                elapsed += wait_chunk
-            if stop_stream_state.value:
-                break
-
-        logging.info("Streaming terminé.")
-
-    except asyncio.CancelledError:
-        logging.info("Stream arrêté par l'utilisateur (CancelledError).")
-        raise
-    except FileNotFoundError:
-        logging.error(f"Erreur critique : Fichier non trouvé : {filepath_to_stream}")
-    except Exception as e:
-        logging.error(f"Erreur pendant le stream: {e}", exc_info=True)
-        raise
-    finally:
-        stop_stream_state.value = False
-        logging.info("Signal d'arrêt nettoyé.")
-
-
-def stop_streaming():
-    """Active le signal d'arrêt pour le générateur."""
-    logging.info("Bouton Stop cliqué: envoi du signal d'arrêt.")
-    stop_stream_state.value = True
-    return None
-
-# --- Interface Gradio ---
-
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "## Application 'Streamer' WebRTC (Serveur -> Client)\n"
-        "Utilisez l'exemple fourni, uploadez un fichier ou enregistrez depuis votre micro, "
-        "puis cliquez sur 'Start' pour écouter le stream."
-    )
-
-    # 1. État pour stocker le chemin du fichier à lire
-    active_filepath = gr.State(value=DEFAULT_FILE)
-
-    with gr.Row():
-        with gr.Column():
-            main_audio = gr.Audio(
-                label="Source Audio",
-                sources=["upload", "microphone"], # Combine les deux sources
-                type="filepath",
-                value=DEFAULT_FILE, # Défaut au premier exemple
+            with gr.Group():
+                with gr.Column():
+                    main_audio = gr.Audio(
+                        label="Audio Input",
+                        sources=["upload", "microphone"],
+                        type="filepath",
+                        interactive=True
+                    )
+
+                    with gr.Accordion("Need a quick test? Try one of the sample audios below", open=True):
+                        examples = gr.Examples(
+                            examples=list(EXAMPLE_CONFIGS.keys()),
+                            inputs=main_audio,
+                            label=None,
+                            examples_per_page=3
+                        )
+                        gr.Markdown(
+                            """
+                            🔹 **english_meeting.wav** – Short business meeting in English  
+                            🔹 **french_news.wav** – Excerpt from a French radio broadcast  
+                            🔹 **spanish_podcast.wav** – Segment from a Spanish-language podcast  
+                            """
+                        )
+
+            btn = gr.Button("Proceed to Streaming", visible=True)
+
+            # ui_components_one = [active_filepath, btn]
+            # main_audio.change(fn=on_file_load, inputs=[main_audio], outputs=ui_components_one)
+            # main_audio.stop_recording(fn=on_file_load, inputs=[main_audio], outputs=ui_components_one)
+            # main_audio.clear(fn=on_file_load, inputs=[main_audio], outputs=ui_components_one)
+
+            btn.click(lambda: gr.Walkthrough(selected=1), outputs=walkthrough)
+
+         # === STEP 2 ===
+        with gr.Step("Stream", id=1) as audio_stream:
+            gr.Markdown("### Step 2: Start audio streaming")
+            with gr.Group():
+                with gr.Column():
+                    webrtc_stream = WebRTC(
+                        label="Live Stream",
+                        mode="receive",
+                        modality="audio",
+                        rtc_configuration=generate_coturn_config(),
+                        visible=True,
+                    )
+            start_button = gr.Button("Start Streaming")
+
+            webrtc_stream.stream(
+                fn=read_and_stream_audio,
+                inputs=[active_filepath, session_hash, stop_streaming_flags],
+                outputs=[webrtc_stream],
+                trigger=start_button.click,
+                concurrency_id="audio_stream",
+                concurrency_limit=10,
             )
-        with gr.Column():
-            webrtc_stream = WebRTC(
-                label="Stream Audio",
-                mode="receive",
-                modality="audio",
-                rtc_configuration=generate_coturn_config(),
-                visible=True, # Caché par défaut
-                height = 200,
+
+            go_to_config = gr.Button("Go to Configuration", visible=False)
+            go_to_config.click(lambda: gr.Walkthrough(selected=2), outputs=walkthrough)
+
+        # === STEP 3 ===
+        with gr.Step("Configuration", id=2):
+            gr.Markdown("## Step 3: Configure the Task")
+
+            task_type = gr.Radio(["Transcription", "Translation"], value="Transcription", label="Task Type")
+            lang_source = gr.Dropdown(list(SUPPORTED_LANGS_MAP.keys()), value="French", label="Source Language")
+            lang_target = gr.Dropdown(list(SUPPORTED_LANGS_MAP.keys()), value="English", label="Target Language", visible=False)
+
+            with gr.Accordion("Advanced Configuration", open=False):
+                chunk_secs = gr.Number(value=1.0, label="chunk_secs", precision=1)
+                left_context_secs = gr.Number(value=20.0, label="left_context_secs", precision=1)
+                right_context_secs = gr.Number(value=0.5, label="right_context_secs", precision=1)
+                streaming_policy = gr.Dropdown(["waitk", "alignatt"], value="waitk", label="decoding.streaming_policy")
+                alignatt_thr = gr.Number(value=8, label="alignatt_thr", precision=0)
+                waitk_lagging = gr.Number(value=2, label="waitk_lagging", precision=0)
+                exclude_sink_frames = gr.Number(value=8, label="exclude_sink_frames", precision=0)
+                xatt_scores_layer = gr.Number(value=-2, label="xatt_scores_layer", precision=0)
+                hallucinations_detector = gr.Checkbox(value=True, label="hallucinations_detector")
+
+            with gr.Row():
+                auto_apply_presets = gr.Checkbox(value=True, label="Auto-apply presets for sample audios")
+                reset_btn = gr.Button("Reset to defaults")
+
+            summary_box = gr.Textbox(label="Configuration Summary", lines=10, interactive=False)
+
+            # --- Events ---
+            task_type.change(
+                fn=lambda t: gr.update(visible=(t == "Translation")),
+                inputs=task_type,
+                outputs=lang_target,
+                queue=False
+            )
+
+            inputs_list = [
+                task_type, lang_source, lang_target,
+                chunk_secs, left_context_secs, right_context_secs,
+                streaming_policy, alignatt_thr, waitk_lagging,
+                exclude_sink_frames, xatt_scores_layer, hallucinations_detector
+            ]
+            for inp in inputs_list:
+                inp.change(
+                    fn=summarize_config,
+                    inputs=inputs_list,
+                    outputs=summary_box,
+                    queue=False
+                )
+
+            # Apply preset or not
+            main_audio.change(
+                fn=apply_preset_if_example,
+                inputs=[main_audio, auto_apply_presets],
+                outputs=[
+                    task_type, lang_source, lang_target,
+                    chunk_secs, left_context_secs, right_context_secs,
+                    streaming_policy, alignatt_thr, waitk_lagging,
+                    exclude_sink_frames, xatt_scores_layer, hallucinations_detector,
+                    summary_box
+                ],
+                queue=False
+            )
+
+            # Reset defaults
+            reset_btn.click(
+                fn=reset_to_defaults,
+                inputs=None,
+                outputs=[
+                    task_type, lang_source, lang_target,
+                    chunk_secs, left_context_secs, right_context_secs,
+                    streaming_policy, alignatt_thr, waitk_lagging,
+                    exclude_sink_frames, xatt_scores_layer, hallucinations_detector,
+                    summary_box
+                ],
+                queue=False
             )
-    # 4. Boutons de contrôle
-    with gr.Row():
-        with gr.Column():
-            start_button = gr.Button("Start Streaming", variant="primary")
-            stop_button = gr.Button("Stop Streaming", variant="stop", interactive=False)
-        with gr.Column():
-            gr.Text()
-
-    def set_new_file(filepath):
-        """Met à jour l'état avec le nouveau chemin, ou revient au défaut si None."""
-        if filepath is None:
-            logging.info("Audio effacé, retour au fichier d'exemple par défaut.")
-            new_path = DEFAULT_FILE
-        else:
-            logging.info(f"Nouvelle source audio sélectionnée : {filepath}")
-            new_path = filepath
-        # Retourne la valeur à mettre dans le gr.State
-        return new_path
-
-    # Mettre à jour le chemin si l'utilisateur upload, efface, ou change le fichier
-    main_audio.change(
-        fn=set_new_file, 
-        inputs=[main_audio], 
-        outputs=[active_filepath]
-    )
-    
-    # Mettre à jour le chemin si l'utilisateur termine un enregistrement
-    main_audio.stop_recording(
-        fn=set_new_file, 
-        inputs=[main_audio], 
-        outputs=[active_filepath]
-    )
-
-
-    # Fonctions pour mettre à jour l'état de l'interface
-    def start_streaming_ui():
-        logging.info("UI : Démarrage du streaming. Désactivation des contrôles.")
-        return {
-            start_button: gr.Button(interactive=False),
-            stop_button: gr.Button(interactive=True),
-            main_audio: gr.Audio(visible=False), 
-        }
-
-    def stop_streaming_ui():
-        logging.info("UI : Arrêt du streaming. Réactivation des contrôles.")
-        return {
-            start_button: gr.Button(interactive=True),
-            stop_button: gr.Button(interactive=False),
-            main_audio: gr.Audio(
-                label="Source Audio",
-                sources=["upload", "microphone"], # Combine les deux sources
-                type="filepath",
-                value=active_filepath.value,
-                visible=True
-        ), 
-            }
-
-
-    ui_components = [
-        start_button, stop_button, 
-        main_audio, 
-    ]
-
-    stream_event = webrtc_stream.stream(
-        fn=read_and_stream_audio,
-        inputs=[active_filepath],  
-        outputs=[webrtc_stream],
-        trigger=start_button.click,
-        concurrency_id="audio_stream", # ID de concurrence
-        concurrency_limit=10
-    )
-
-    # Mettre à jour l'interface au clic sur START
-    start_button.click(
-        fn=start_streaming_ui,
-        outputs=ui_components
-    )
-
-    # Correction : S'assurer que le stream est bien annulé
-    stop_button.click(
-        fn=stop_streaming, 
-        outputs=[webrtc_stream], 
-    ).then(
-        fn=stop_streaming_ui, # ENSUITE, mettre à jour l'interface
-        inputs=None,
-        outputs=ui_components
-    )
+
+            go_to_task = gr.Button("Go to Task")
+            go_to_task.click(lambda: gr.Walkthrough(selected=3), outputs=walkthrough)
+
+        # === STEP 4 ===
+        with gr.Step("Task", id=3) as task_step:
+            gr.Markdown("## Step 4: Start the Task")
+
+            with gr.Group():
+                with gr.Column():
+                    status_slider = gr.Slider(
+                        0, 100,
+                        value=0,
+                        label="Streaming Progress",
+                        interactive=False,
+                        visible=False
+                    )
+
+                    transcription_output = gr.Textbox(
+                        label="Transcription / Translation Result",
+                        placeholder="The output text will appear here...",
+                        lines=10,
+                        interactive=False,
+                        visible=True
+                    )
+
+                    start_task_button = gr.Button("Start Task", visible=True)
+                    stop_button = gr.Button("Stop Streaming", visible=False)
+                    stop_task_button = gr.Button("Stop Task", visible=False)
+
+                    stop_button.click(
+                        fn=stop_streaming,
+                        inputs=[session_hash, stop_streaming_flags],
+                        outputs=[stop_streaming_flags],
+                    )
+
+                    def stop_task_fn():
+                        return "Task stopped by user."
+
+                    stop_task_button.click(
+                        fn=stop_task_fn,
+                        inputs=None,
+                        outputs=transcription_output
+                    )
+
+                    ui_components = [
+                        start_button, stop_button,
+                        go_to_config, audio_source_step, status_slider
+                    ]
+
+                    webrtc_stream.on_additional_outputs(
+                        fn=handle_additional_outputs,
+                        outputs=ui_components,
+                        concurrency_id="additional_outputs_audio_stream",
+                        concurrency_limit=10,
+                    )
+
+                    # def start_transcription(
+                    #     session_hash, stop_streaming_flags,
+                    #     task_type, lang_source, lang_target,
+                    #     chunk_secs, left_context_secs, right_context_secs,
+                    #     streaming_policy, alignatt_thr, waitk_lagging,
+                    #     exclude_sink_frames, xatt_scores_layer, hallucinations_detector
+                    # ):
+                    #     if task_type == "Translation":
+                    #         return f"Translation completed ({lang_source} → {lang_target})\n\nTranslated text:\nLorem ipsum..."
+                    #     else:
+                    #         return f"Transcription completed ({lang_source})\n\nTranscribed text:\nHello everyone, this is a test audio stream..."
+
+                    # start_task_button.click(
+                    #     fn=start_transcription,
+                    #     inputs=[
+                    #         session_hash, stop_streaming_flags,
+                    #         task_type, lang_source, lang_target,
+                    #         chunk_secs, left_context_secs, right_context_secs,
+                    #         streaming_policy, alignatt_thr, waitk_lagging,
+                    #         exclude_sink_frames, xatt_scores_layer, hallucinations_detector
+                    #     ],
+                    #     outputs=transcription_output
+                    # )
+
+                    # def toggle_task_buttons():
+                    #     return (
+                    #         gr.update(visible=False),
+                    #         gr.update(visible=True),
+                    #         gr.update(visible=True)
+                    #     )
+
+                    # start_task_button.click(
+                    #     fn=toggle_task_buttons,
+                    #     inputs=None,
+                    #     outputs=[start_task_button, stop_task_button, stop_button],
+                    #     queue=False
+                    # )
 
 
 if __name__ == "__main__":
-    demo.queue(max_size=10, api_open=False).launch(show_api=False, debug=True)
+    demo.queue(max_size=10, api_open=False).launch(show_api=False, debug=True)

app/logger_config.py

@@ -11,7 +11,6 @@ import os
 # nemo_logger.remove_stream_handlers()
 
 DEBUG = os.getenv("DEBUG", "false").lower() == "true"
-print(DEBUG)
 # Create "logs" directory if it doesn't exist
 os.makedirs("logs", exist_ok=True)
 

app/old_session_utils.py

@@ -0,0 +1,273 @@
+import os
+import json
+import uuid
+import shutil
+from datetime import datetime
+from app.logger_config import logger as logging
+import gradio as gr
+# TMP_DIR = "/tmp/canary_aed_streaming"
+
+TMP_DIR = os.getenv("TMP_DIR", "/tmp/canary_aed_streaming")
+ACTIVE_SESSIONS_FILE = os.path.join(TMP_DIR, "active_sessions.json")
+
+
+# ---------------------------
+# Helper to manage the JSON
+# ---------------------------
+def _read_sessions():
+    if not os.path.exists(ACTIVE_SESSIONS_FILE):
+        return {}
+    try:
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _write_sessions(data):
+    os.makedirs(os.path.dirname(ACTIVE_SESSIONS_FILE), exist_ok=True)
+    with open(ACTIVE_SESSIONS_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+# ---------------------------
+# LOAD
+# ---------------------------
+def on_load(request: gr.Request):
+    """Called when a new visitor opens the app."""
+    sid = request.session_hash  # ✅ Directly use session_hash as unique ID
+    sessions = _read_sessions()
+
+    sessions[sid] = {
+        "session_id": sid,
+        "file": "",
+        "start_time": datetime.utcnow().strftime("%H:%M:%S"),
+        "status": "active",
+    }
+
+    _write_sessions(sessions)
+    logging.info(f"[{sid}] Session registered (on_load).")
+
+    return sid, sid  # can be used as gr.State + display
+
+
+# ---------------------------
+# UNLOAD
+# ---------------------------
+def on_unload(request: gr.Request):
+    """Called when the visitor closes or refreshes the app."""
+    sid = request.session_hash
+    sessions = _read_sessions()
+
+    if sid in sessions:
+        create_stop_flag(sid)
+        sessions.pop(sid)
+        _write_sessions(sessions)
+        remove_session_data(sid)
+        unregister_session(sid)
+        logging.info(f"[{sid}] Session removed (on_unload).")
+    else:
+        logging.info(f"[{sid}] No active session found to remove.")
+
+def ensure_tmp_dir():
+    """Ensures the base temporary directory exists."""
+    try:
+        os.makedirs(TMP_DIR, exist_ok=True)
+    except Exception as e:
+        logging.error(f"Failed to create tmp directory {TMP_DIR}: {e}")
+
+
+def reset_all_active_sessions():
+    """Removes all temporary session files and folders at startup."""
+    ensure_tmp_dir()
+
+    try:
+        # --- Remove active sessions file ---
+        if os.path.exists(ACTIVE_SESSIONS_FILE):
+            os.remove(ACTIVE_SESSIONS_FILE)
+            logging.info("Active sessions file reset at startup.")
+        else:
+            logging.debug("No active sessions file found to reset.")
+
+        # --- Clean progress files ---
+        for f in os.listdir(TMP_DIR):
+            if f.startswith("progress_") and f.endswith(".json"):
+                path = os.path.join(TMP_DIR, f)
+                try:
+                    os.remove(path)
+                    logging.debug(f"Removed leftover progress file: {f}")
+                except Exception as e:
+                    logging.warning(f"Failed to remove progress file {f}: {e}")
+
+        # --- Clean all flag files (stream + transcribe) ---
+        for f in os.listdir(TMP_DIR):
+            if (
+                f.startswith("stream_stop_flag_")
+                or f.startswith("transcribe_stop_flag_")
+                or f.startswith("transcribe_active_")
+            ) and f.endswith(".txt"):
+                path = os.path.join(TMP_DIR, f)
+                try:
+                    os.remove(path)
+                    logging.debug(f"Removed leftover flag file: {f}")
+                except Exception as e:
+                    logging.warning(f"Failed to remove flag file {f}: {e}")
+
+        # --- Clean chunk directories ---
+        for name in os.listdir(TMP_DIR):
+            path = os.path.join(TMP_DIR, name)
+            if os.path.isdir(path) and name.startswith("chunks_"):
+                try:
+                    shutil.rmtree(path)
+                    logging.debug(f"Removed leftover chunk folder: {name}")
+                except Exception as e:
+                    logging.warning(f"Failed to remove chunk folder {name}: {e}")
+
+        logging.info("Temporary session cleanup completed successfully.")
+
+    except Exception as e:
+        logging.error(f"Error resetting active sessions: {e}")
+
+def remove_session_data(session_id: str):
+    """Removes all temporary files and data related to a specific session."""
+    if not session_id:
+        logging.warning("reset_session() called without a valid session_id.")
+        return
+
+    try:
+        # --- Remove session from active_sessions.json ---
+        if os.path.exists(ACTIVE_SESSIONS_FILE):
+            try:
+                with open(ACTIVE_SESSIONS_FILE, "r") as f:
+                    data = json.load(f)
+                if session_id in data:
+                    data.pop(session_id)
+                    with open(ACTIVE_SESSIONS_FILE, "w") as f:
+                        json.dump(data, f, indent=2)
+                    logging.debug(f"[{session_id}] Removed from active_sessions.json.")
+            except Exception as e:
+                logging.warning(f"[{session_id}] Failed to update active_sessions.json: {e}")
+
+        # --- Define all possible session file patterns ---
+        files_to_remove = [
+            f"progress_{session_id}.json",
+            # f"stream_stop_flag_{session_id}.txt",
+            f"transcribe_stop_flag_{session_id}.txt",
+            f"transcribe_active_{session_id}.txt",
+        ]
+
+        # --- Remove all temporary files ---
+        for fname in files_to_remove:
+            path = os.path.join(TMP_DIR, fname)
+            if os.path.exists(path):
+                try:
+                    os.remove(path)
+                    logging.debug(f"[{session_id}] Removed file: {fname}")
+                except Exception as e:
+                    logging.warning(f"[{session_id}] Failed to remove file {fname}: {e}")
+
+        # --- Remove chunk folder if exists ---
+        chunk_dir = os.path.join(TMP_DIR, f"chunks_{session_id}")
+        if os.path.isdir(chunk_dir):
+            try:
+                shutil.rmtree(chunk_dir)
+                logging.debug(f"[{session_id}] Removed chunk folder: chunks_{session_id}")
+            except Exception as e:
+                logging.warning(f"[{session_id}] Failed to remove chunk folder: {e}")
+
+        logging.info(f"[{session_id}] Session fully reset.")
+
+    except Exception as e:
+        logging.error(f"[{session_id}] Error during reset_session: {e}")
+def generate_session_id() -> str:
+    """Generates a unique session ID."""
+    sid = str(uuid.uuid4())
+    logging.debug(f"[{sid}] New session created.")
+    return sid
+
+
+def register_session(session_id: str, filepath: str):
+    """Registers a new session."""
+    ensure_tmp_dir()
+    data = {}
+    if os.path.exists(ACTIVE_SESSIONS_FILE):
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            try:
+                data = json.load(f)
+            except Exception:
+                data = {}
+
+    data[session_id] = {
+        "session_id": session_id,
+        "file": filepath,
+        "start_time": datetime.utcnow().strftime("%H:%M:%S"),
+        "status": "active",
+    }
+
+    with open(ACTIVE_SESSIONS_FILE, "w") as f:
+        json.dump(data, f)
+
+    logging.debug(f"[{session_id}] Session registered in active_sessions.json.")
+
+
+def unregister_session(session_id: str):
+    """Removes a session from the registry."""
+    if not os.path.exists(ACTIVE_SESSIONS_FILE):
+        return
+
+    try:
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            data = json.load(f)
+        if session_id in data:
+            data.pop(session_id)
+            with open(ACTIVE_SESSIONS_FILE, "w") as f:
+                json.dump(data, f)
+            logging.debug(f"[{session_id}] Session unregistered.")
+    except Exception as e:
+        logging.error(f"[{session_id}] Error unregistering session: {e}")
+
+
+def get_active_sessions():
+    """Returns active sessions as a list of rows for the DataFrame."""
+    if not os.path.exists(ACTIVE_SESSIONS_FILE):
+        return []
+
+    try:
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            data = json.load(f)
+
+        rows = [
+            [
+                s.get("session_id", ""),
+                s.get("file", ""),
+                s.get("start_time", ""),
+                s.get("status", ""),
+            ]
+            for s in data.values()
+        ]
+        return rows
+    except Exception as e:
+        logging.error(f"Error reading active sessions: {e}")
+        return []
+
+
+def stop_file_path(session_id: str) -> str:
+    """Returns the stop-flag file path for a given session."""
+    ensure_tmp_dir()
+    return os.path.join(TMP_DIR, f"stream_stop_flag_{session_id}.txt")
+
+
+def create_stop_flag(session_id: str):
+    """Creates a stop-flag file for this session."""
+    path = stop_file_path(session_id)
+    with open(path, "w") as f:
+        f.write("1")
+    logging.info(f"[{session_id}] Stop flag file created at {path}.")
+
+
+def clear_stop_flag(session_id: str):
+    """Deletes the stop-flag file if it exists."""
+    path = stop_file_path(session_id)
+    if os.path.exists(path):
+        os.remove(path)
+        logging.debug(f"[{session_id}] Stop flag cleared.")

app/session_utils.py

@@ -35,20 +35,20 @@ def _write_sessions(data):
 # ---------------------------
 def on_load(request: gr.Request):
     """Called when a new visitor opens the app."""
-    sid = request.session_hash  # ✅ Directly use session_hash as unique ID
+    session_hash = request.session_hash  # ✅ Directly use session_hash as unique ID
     sessions = _read_sessions()
 
-    sessions[sid] = {
-        "session_id": sid,
+    sessions[session_hash] = {
+        "session_hash": session_hash,
         "file": "",
         "start_time": datetime.utcnow().strftime("%H:%M:%S"),
         "status": "active",
     }
 
     _write_sessions(sessions)
-    logging.info(f"[{sid}] Session registered (on_load).")
+    logging.info(f"[{session_hash}] Session registered (on_load).")
 
-    return sid, sid  # can be used as gr.State + display
+    return session_hash, session_hash  # can be used as gr.State + display
 
 
 # ---------------------------
@@ -60,7 +60,6 @@ def on_unload(request: gr.Request):
     sessions = _read_sessions()
 
     if sid in sessions:
-        create_stop_flag(sid)
         sessions.pop(sid)
         _write_sessions(sessions)
         remove_session_data(sid)
@@ -88,43 +87,7 @@ def reset_all_active_sessions():
             logging.info("Active sessions file reset at startup.")
         else:
             logging.debug("No active sessions file found to reset.")
-
-        # --- Clean progress files ---
-        for f in os.listdir(TMP_DIR):
-            if f.startswith("progress_") and f.endswith(".json"):
-                path = os.path.join(TMP_DIR, f)
-                try:
-                    os.remove(path)
-                    logging.debug(f"Removed leftover progress file: {f}")
-                except Exception as e:
-                    logging.warning(f"Failed to remove progress file {f}: {e}")
-
-        # --- Clean all flag files (stream + transcribe) ---
-        for f in os.listdir(TMP_DIR):
-            if (
-                f.startswith("stream_stop_flag_")
-                or f.startswith("transcribe_stop_flag_")
-                or f.startswith("transcribe_active_")
-            ) and f.endswith(".txt"):
-                path = os.path.join(TMP_DIR, f)
-                try:
-                    os.remove(path)
-                    logging.debug(f"Removed leftover flag file: {f}")
-                except Exception as e:
-                    logging.warning(f"Failed to remove flag file {f}: {e}")
-
-        # --- Clean chunk directories ---
-        for name in os.listdir(TMP_DIR):
-            path = os.path.join(TMP_DIR, name)
-            if os.path.isdir(path) and name.startswith("chunks_"):
-                try:
-                    shutil.rmtree(path)
-                    logging.debug(f"Removed leftover chunk folder: {name}")
-                except Exception as e:
-                    logging.warning(f"Failed to remove chunk folder {name}: {e}")
-
-        logging.info("Temporary session cleanup completed successfully.")
-
+       
     except Exception as e:
         logging.error(f"Error resetting active sessions: {e}")
 
@@ -198,7 +161,7 @@ def register_session(session_id: str, filepath: str):
                 data = {}
 
     data[session_id] = {
-        "session_id": session_id,
+        "session_hash": session_id,
         "file": filepath,
         "start_time": datetime.utcnow().strftime("%H:%M:%S"),
         "status": "active",
@@ -238,7 +201,7 @@ def get_active_sessions():
 
         rows = [
             [
-                s.get("session_id", ""),
+                s.get("session_hash", ""),
                 s.get("file", ""),
                 s.get("start_time", ""),
                 s.get("status", ""),
@@ -251,23 +214,7 @@ def get_active_sessions():
         return []
 
 
-def stop_file_path(session_id: str) -> str:
-    """Returns the stop-flag file path for a given session."""
-    ensure_tmp_dir()
-    return os.path.join(TMP_DIR, f"stream_stop_flag_{session_id}.txt")
 
 
-def create_stop_flag(session_id: str):
-    """Creates a stop-flag file for this session."""
-    path = stop_file_path(session_id)
-    with open(path, "w") as f:
-        f.write("1")
-    logging.info(f"[{session_id}] Stop flag file created at {path}.")
 
 
-def clear_stop_flag(session_id: str):
-    """Deletes the stop-flag file if it exists."""
-    path = stop_file_path(session_id)
-    if os.path.exists(path):
-        os.remove(path)
-        logging.debug(f"[{session_id}] Stop flag cleared.")

app/stream_utils.py

@@ -0,0 +1,102 @@
+
+from app.logger_config import logger as logging
+from fastrtc.utils import AdditionalOutputs
+from pydub import AudioSegment
+import asyncio
+import os
+import time
+import numpy as np
+
+# --------------------------------------------------------
+# Utility functions
+# --------------------------------------------------------
+
+def read_and_stream_audio(filepath_to_stream: str, session_id: str, stop_streaming_flags: dict):
+    """
+    Read an audio file and stream it chunk by chunk (1s per chunk).
+    Handles errors safely and reports structured messages to the client.
+    """
+    if not session_id:
+        yield from handle_stream_error("unknown", "No session_id provided.", stop_streaming_flags)
+        return
+
+    if not filepath_to_stream or not os.path.exists(filepath_to_stream):
+        yield from handle_stream_error(session_id, f"Audio file not found: {filepath_to_stream}", stop_streaming_flags)
+        return
+
+    try:
+        segment = AudioSegment.from_file(filepath_to_stream)
+        chunk_duration_ms = 1000
+        total_chunks = len(segment) // chunk_duration_ms + 1
+        logging.info(f"[{session_id}] Starting audio streaming ({total_chunks} chunks).")
+
+        for i, chunk in enumerate(segment[::chunk_duration_ms]):
+            if _is_stop_requested(stop_streaming_flags):
+                logging.info(f"[{session_id}] Stop signal received. Terminating stream.")
+                break
+
+            frame_rate = chunk.frame_rate
+            samples = np.array(chunk.get_array_of_samples()).reshape(1, -1)
+            progress = round(((i + 1) / total_chunks) * 100, 2)
+
+            yield ((frame_rate, samples), AdditionalOutputs(progress))
+            logging.debug(f"[{session_id}] Sent chunk {i+1}/{total_chunks} ({progress}%).")
+
+            time.sleep(1)
+            # raise_function()  # Optional injected test exception
+
+        logging.info(f"[{session_id}] Audio streaming completed successfully.")
+
+    except asyncio.CancelledError:
+        yield from handle_stream_error(session_id, "Streaming cancelled by user.", stop_streaming_flags)
+    except FileNotFoundError as e:
+        yield from handle_stream_error(session_id, e, stop_streaming_flags)
+    except Exception as e:
+        yield from handle_stream_error(session_id, e, stop_streaming_flags)
+    finally:
+        if isinstance(stop_streaming_flags, dict):
+            stop_streaming_flags["stop"] = False
+        logging.info(f"[{session_id}] Stop flag reset.")
+        yield (None, AdditionalOutputs("STREAM_DONE"))
+
+
+
+def handle_stream_error(session_id: str, error: Exception | str, stop_streaming_flags: dict | None = None):
+    """
+    Handle streaming errors:
+    - Log the error
+    - Send structured info to client
+    - Reset stop flag
+    """
+    if isinstance(error, Exception):
+        msg = f"{type(error).__name__}: {str(error)}"
+    else:
+        msg = str(error)
+
+    logging.error(f"[{session_id}] Streaming error: {msg}", exc_info=isinstance(error, Exception))
+
+    if isinstance(stop_streaming_flags, dict):
+        stop_streaming_flags["stop"] = False
+
+    yield (None, AdditionalOutputs({"error": True, "message": msg}))
+    yield (None, AdditionalOutputs("STREAM_DONE"))
+
+
+def _is_stop_requested(stop_streaming_flags: dict) -> bool:
+    """Check if the stop signal was requested."""
+    if not isinstance(stop_streaming_flags, dict):
+        return False
+    return bool(stop_streaming_flags.get("stop", False))
+
+
+
+def stop_streaming(session_id: str, stop_streaming_flags: dict):
+    """Trigger the stop flag for active streaming."""
+    logging.info(f"[{session_id}] Stop button clicked — sending stop signal.")
+    if not isinstance(stop_streaming_flags, dict):
+        stop_streaming_flags = {"stop": True}
+    else:
+        stop_streaming_flags["stop"] = True
+    return stop_streaming_flags
+
+

app/ui_utils.py

@@ -0,0 +1,203 @@
+from app.logger_config import logger as logging
+import gradio as gr
+from pathlib import Path
+import os
+DEFAULT_CONFIG = {
+    "task_type": "Transcription",
+    "lang_source": "French",
+    "lang_target": "English",
+    "chunk_secs": 1.0,
+    "left_context_secs": 20.0,
+    "right_context_secs": 0.5,
+    "streaming_policy": "waitk",
+    "alignatt_thr": 8,
+    "waitk_lagging": 2,
+    "exclude_sink_frames": 8,
+    "xatt_scores_layer": -2,
+    "hallucinations_detector": True,
+}
+
+
+EXAMPLE_CONFIGS = {
+    "data/english_meeting.wav": {
+        "task_type": "Transcription", "lang_source": "English", "lang_target": "English",
+        "chunk_secs": 1.0, "left_context_secs": 20.0, "right_context_secs": 0.5,
+        "streaming_policy": "waitk", "alignatt_thr": 8, "waitk_lagging": 2,
+        "exclude_sink_frames": 8, "xatt_scores_layer": -2, "hallucinations_detector": True
+    },
+    "data/french_news.wav": {
+        "task_type": "Transcription", "lang_source": "French", "lang_target": "English",
+        "chunk_secs": 1.0, "left_context_secs": 15.0, "right_context_secs": 0.3,
+        "streaming_policy": "alignatt", "alignatt_thr": 10, "waitk_lagging": 3,
+        "exclude_sink_frames": 6, "xatt_scores_layer": -1, "hallucinations_detector": True
+    },
+    "data/spanish_podcast.wav": {
+        "task_type": "Translation", "lang_source": "Spanish", "lang_target": "English",
+        "chunk_secs": 1.5, "left_context_secs": 25.0, "right_context_secs": 0.4,
+        "streaming_policy": "waitk", "alignatt_thr": 7, "waitk_lagging": 1,
+        "exclude_sink_frames": 8, "xatt_scores_layer": -2, "hallucinations_detector": False
+    }
+}
+
+SUPPORTED_LANGS_MAP = {
+    "Bulgarian": "bg", "Croatian": "hr", "Czech": "cs", "Danish": "da",
+    "Dutch": "nl", "English": "en", "Estonian": "et", "Finnish": "fi",
+    "French": "fr", "German": "de", "Greek": "el", "Hungarian": "hu",
+    "Italian": "it", "Latvian": "lv", "Lithuanian": "lt", "Maltese": "mt",
+    "Polish": "pl", "Portuguese": "pt", "Romanian": "ro", "Slovak": "sk",
+    "Slovenian": "sl", "Spanish": "es", "Swedish": "sv", "Russian": "ru", "Ukrainian": "uk"
+}
+
+
+
+# ========== FONCTIONS UTILITAIRES ==========
+
+def to_updates(cfg):
+    """Map dict -> gr.update list dans l'ordre des sorties."""
+    return [
+        gr.update(value=cfg["task_type"]),
+        gr.update(value=cfg["lang_source"]),
+        gr.update(
+            value=cfg["lang_target"],
+            visible=(cfg["task_type"] == "Translation")
+        ),
+        gr.update(value=cfg["chunk_secs"]),
+        gr.update(value=cfg["left_context_secs"]),
+        gr.update(value=cfg["right_context_secs"]),
+        gr.update(value=cfg["streaming_policy"]),
+        gr.update(value=cfg["alignatt_thr"]),
+        gr.update(value=cfg["waitk_lagging"]),
+        gr.update(value=cfg["exclude_sink_frames"]),
+        gr.update(value=cfg["xatt_scores_layer"]),
+        gr.update(value=cfg["hallucinations_detector"]),
+    ]
+
+def apply_preset_if_example(filepath, auto_apply):
+    """Si fichier = exemple ET auto_apply=True -> applique preset. Sinon, ne rien changer."""
+    logging.info(f"apply_preset_if_example {filepath} {auto_apply} ")
+    if not filepath or not auto_apply:
+        updates = [gr.update() for _ in range(12)]
+        updates.append(gr.update())
+        return tuple(updates)
+
+    # On compare uniquement le nom de fichier, pas le chemin complet
+    file_name = Path(filepath).name
+
+    # Recherche dans EXAMPLE_CONFIGS par nom de fichier
+    cfg = next(
+        (config for path, config in EXAMPLE_CONFIGS.items() if Path(path).name == file_name),
+        None
+    )
+
+    if not cfg:
+        updates = [gr.update() for _ in range(12)]
+        updates.append(gr.update())
+        return tuple(updates)
+
+    updates = to_updates(cfg)
+    updates.append(gr.update(value=f"Preset applied for: {file_name}"))
+    return tuple(updates)
+
+def reset_to_defaults():
+    """Réinitialise tous les champs aux valeurs par défaut."""
+    updates = to_updates(DEFAULT_CONFIG)  # 12 champs
+    # Ajout du résumé (13e sortie)
+    updates.append(gr.update(value="Defaults restored."))
+    return tuple(updates)
+
+def summarize_config(
+    task, src, tgt,
+    chunk, left, right,
+    policy, thr, lag, sink, xatt, halluc
+):
+    txt = f"🧠 **Task:** {task}\n🌐 **Source language:** {src}"
+    if task == "Translation":
+        txt += f"\n🎯 **Target language:** {tgt}"
+    txt += (
+        f"\n\n### ⚙️ Advanced Parameters:\n"
+        f"- chunk_secs = {chunk}\n"
+        f"- left_context_secs = {left}\n"
+        f"- right_context_secs = {right}\n"
+        f"- decoding.streaming_policy = {policy}\n"
+        f"- decoding.alignatt_thr = {thr}\n"
+        f"- decoding.waitk_lagging = {lag}\n"
+        f"- decoding.exclude_sink_frames = {sink}\n"
+        f"- decoding.xatt_scores_layer = {xatt}\n"
+        f"- decoding.hallucinations_detector = {halluc}"
+    )
+    return txt
+
+def handle_additional_outputs( progress_value):
+    """
+    Update UI elements based on streaming progress or errors.
+    Controls button states, audio visibility, and progress slider.
+    """
+    logging.debug(f"Additional output received: {progress_value}")
+    # ui_components = [start_button, stop_button,go_to_task, audio_source_step, status_slider]
+
+    # Handle structured error message
+    non_ok= (
+            gr.update(visible=True),   # start_button enabled
+            gr.update(visible=False),  # stop_button disabled
+            gr.update(visible=False),  # go_to_task disabled
+            gr.update(interactive=True),       # audio_source_step re-shown
+            gr.update(visible=False, value=0),  # slider hidden
+        )
+    if isinstance(progress_value, dict) and progress_value.get("error"):
+        msg = progress_value.get("message", "Unknown error.")
+        logging.error(f"[stream_ui] Client-side error: {msg}")
+        return non_ok
+
+    try:
+        progress = float(progress_value)
+    except (ValueError, TypeError):
+        progress = 0
+
+    # --- Stream not started ---
+    if progress <= 0:
+        return non_ok
+
+    # --- Stream finished ---
+    if progress >= 100:
+        return non_ok
+
+    # --- Stream in progress ---
+    return (
+        gr.update(visible=False),      # start_button disabled
+        gr.update(visible=True),       # stop_button enabled
+        gr.update(visible=True),  # go_to_task enabled
+        gr.update(interactive=False),          # hide audio_source_step
+        gr.update(visible=True, value=progress), # show progress
+    )
+
+
+def on_file_load(filepath):
+    """
+   Update active audio path or reset".
+    """
+    # Si un fichier est chargé (upload, micro, ou exemple),
+    # audio_path ne sera pas None.
+    is_visible = filepath is not None
+    return filepath, gr.update(visible=is_visible)
+
+
+
+def get_custom_theme() :
+    # === Thème personnalisé (studio néon) ===
+    theme = gr.themes.Base(
+        primary_hue="blue",
+        secondary_hue="indigo",
+    ).set(
+        body_background_fill="#F7F8FA",
+        body_text_color="#222222",
+        block_border_color="#D0D3D9",
+        button_primary_background_fill="#3B82F6",
+        button_primary_background_fill_hover="#2563EB",
+        button_primary_text_color="#FFFFFF",
+    )
+
+
+    css_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "assets", "custom_style.css")
+    with open(css_path, encoding="utf-8") as f:
+        css_style = f.read()
+    return theme, css_style

app/utils.py

@@ -5,6 +5,7 @@ import hashlib
 import base64
 import os
 import time
+import random
 
 def debug_current_device():
     """Safely logs GPU or CPU information without crashing on stateless GPU."""
@@ -85,4 +86,14 @@ def generate_coturn_config():
             }
         ]
     }
-    return coturn_config
+    return coturn_config
+
+
+
+
+
+
+def raise_function():
+    """Raise an error randomly (1 out of 10 times)."""
+    if random.randint(1, 50) == 1:
+        raise RuntimeError("Random failure triggered!")

assets/custom_style.css

@@ -0,0 +1,137 @@
+:root {
+  --accent-blue: #3B82F6;
+  --accent-indigo: #6366F1;
+  --light-bg: #FFFFFF;
+  --soft-shadow: 0 4px 15px rgba(0, 0, 0, 0.05);
+}
+#root, .gradio-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.gradio-container {
+  max-width: 960px;
+  min-width: 960px; 
+  margin: 0 auto !important;
+  padding: 1.5rem;
+}
+body {
+  background: #F4F6F8;
+  display: flex;
+  justify-content: center;
+}
+@media (max-width: 768px) {
+  .gradio-container {
+    max-width: 95%;
+    padding: 0.5rem;
+  }
+  .gr-button {
+    width: 100%;
+  }
+}
+.gr-block {
+  width: 100%;
+  margin: 0 auto;
+  border-radius: 12px;
+  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.05);
+}
+.gr-button {
+  background: var(--accent-blue);
+  border-radius: 10px;
+  box-shadow: var(--soft-shadow);
+  transition: all 0.25s ease;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+.gr-button:hover {
+  background: var(--accent-indigo);
+  transform: translateY(-2px);
+}
+.gr-block {
+  background: var(--light-bg);
+  border: 1px solid #E5E7EB;
+  border-radius: 12px;
+  box-shadow: var(--soft-shadow);
+  padding: 12px;
+}
+.gr-markdown h2 {
+  color: #1E3A8A;
+  font-weight: 700;
+}
+.gr-radio, .gr-dropdown, .gr-number, .gr-checkbox {
+  max-width: 320px;
+  margin: 0.5rem auto;
+}
+.gr-textbox {
+  max-width: 600px;
+  margin: 1rem auto;
+}
+.gr-button {
+  max-width: 250px;
+  margin: 1rem auto;
+  display: block;
+}
+/* ==== Custom style for examples section ==== */
+/* === Clean style for audio examples === */
+.gr-examples {
+  background: #FFFFFF !important;           /* fond blanc */
+  border: 1px solid #E5E7EB !important;     /* bordure légère */
+  border-radius: 10px !important;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.03);
+  padding: 0.5rem 1rem !important;
+}
+
+.gr-examples .example {
+  background: #FAFAFA !important;           /* gris ultra clair */
+  border: 1px solid #E5E7EB !important;
+  border-radius: 8px !important;
+  color: #1F2937 !important;
+  font-weight: 500;
+  transition: all 0.2s ease-in-out;
+}
+
+.gr-examples .example:hover {
+  background: #EFF6FF !important;           /* bleu très clair au survol */
+  border-color: #3B82F6 !important;
+  transform: translateY(-1px);
+  cursor: pointer;
+}
+
+.gr-examples-label {
+  font-weight: 600;
+  color: #1E3A8A;
+  margin-bottom: 0.5rem;
+  background: transparent !important;
+  border: none !important;
+}
+
+/* supprime le fond gris hérité sur le conteneur interne */
+.gr-panel {
+  background: transparent !important;
+  border: none !important;
+}
+/* === Smooth step transition animation === */
+[data-testid="block"] {
+  opacity: 0;
+  ransform: translateY(10px) scale(0.98);;
+  transition: opacity 0.5s ease, transform 0.5s ease;
+}
+
+/* Step visible (Gradio auto-class) */
+[data-testid="block"].svelte-drum21, 
+[data-testid="block"]:not([style*="display: none"]) {
+  opacity: 1 !important;
+  ransform: translateY(10px) scale(0.98); !important;
+}
+
+/* Smooth transitions when changing steps */
+.gr-walkthrough > div {
+  transition: all 0.4s ease-in-out;
+}
+
+/* Optional: soft highlight on current step */
+.gr-step-header[data-selected="true"] {
+  background: #EFF6FF !important;
+  border-radius: 6px;
+  box-shadow: 0 0 6px rgba(59,130,246,0.3);
+}

data/english_meeting.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea84e513e9d6ef3cb69638fb658d581b9c3979c50559fa0d196d2e3896b7d9c8
+size 21024206

data/french_news.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea84e513e9d6ef3cb69638fb658d581b9c3979c50559fa0d196d2e3896b7d9c8
+size 21024206

data/spanish_podcast.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea84e513e9d6ef3cb69638fb658d581b9c3979c50559fa0d196d2e3896b7d9c8
+size 21024206

old_app.py

@@ -0,0 +1,427 @@
+from app.logger_config import logger as logging
+import numpy as np
+import gradio as gr
+import asyncio
+from fastrtc.webrtc import WebRTC
+from fastrtc.utils import AdditionalOutputs
+from pydub import AudioSegment
+import time
+import os
+import json
+import spaces
+from app.utils import generate_coturn_config,raise_function
+
+from app.old_session_utils import (
+    TMP_DIR,
+    generate_session_id,
+    register_session,
+    unregister_session,
+    get_active_sessions,
+    stop_file_path,
+    create_stop_flag,
+    clear_stop_flag,
+    reset_all_active_sessions,
+    on_load,
+    on_unload
+
+)
+
+# Reset sessions at startup
+reset_all_active_sessions()
+
+EXAMPLE_FILES = ["data/bonjour.wav", "data/bonjour2.wav"]
+DEFAULT_FILE = EXAMPLE_FILES[0]
+
+
+# --------------------------------------------------------
+# STREAMING
+# --------------------------------------------------------
+def read_and_stream_audio(filepath_to_stream: str, session_id: str, chunk_seconds: float):
+    """Stream audio chunks and save .npz files only when transcription is active."""
+    stop_file = os.path.join(TMP_DIR, f"stream_stop_flag_{session_id}.txt")
+    transcribe_flag = os.path.join(TMP_DIR, f"transcribe_active_{session_id}.txt")
+
+    logging.debug(f"[{session_id}] read_and_stream_audio() started with file: {filepath_to_stream}")
+
+    try:
+        if not filepath_to_stream or not os.path.exists(filepath_to_stream):
+            logging.error(f"[{session_id}] Audio file not found: {filepath_to_stream}")
+            raise f"Audio file not found: {filepath_to_stream}"
+        clear_stop_flag(session_id)
+        register_session(session_id, filepath_to_stream)
+        progress_path = os.path.join(TMP_DIR, f"progress_{session_id}.json")    
+
+
+        segment = AudioSegment.from_file(filepath_to_stream)
+        chunk_ms = int(chunk_seconds * 1000)
+        total_chunks = len(segment) // chunk_ms + 1
+
+        logging.info(f"[{session_id}] Streaming {total_chunks} chunks ({chunk_seconds:.2f}s each)...")
+
+        for i, chunk in enumerate(segment[::chunk_ms], start=1):
+            if os.path.exists(stop_file):
+                logging.info(f"[{session_id}] Stop flag detected at chunk {i}. Ending stream.")
+                clear_stop_flag(session_id)
+                break
+            logging.info(f"[{session_id}] Streaming chunk {i}.")
+            iter_start = time.perf_counter()
+
+            elapsed_s = i * chunk_seconds
+            hours, remainder = divmod(int(elapsed_s), 3600)
+            minutes, seconds = divmod(remainder, 60)
+            elapsed_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+            percent = round((i / total_chunks) * 100, 2)
+            progress_data = {"value": percent, "elapsed": elapsed_str}
+            with open(progress_path, "w") as f:
+                json.dump(progress_data, f)
+            chunk_array = np.array(chunk.get_array_of_samples(), dtype=np.int16)
+            rate = chunk.frame_rate
+            #  Save only if transcription is active
+            if os.path.exists(transcribe_flag) :
+                chunk_dir = os.path.join(TMP_DIR, f"chunks_{session_id}")
+                if not os.path.exists(chunk_dir) : 
+                    os.makedirs(chunk_dir, exist_ok=True)
+                npz_path = os.path.join(chunk_dir, f"chunk_{i:05d}.npz")
+                np.savez_compressed(npz_path, data=chunk_array, rate=rate)
+                logging.debug(f"[{session_id}] Saved chunk {i}/{total_chunks} (transcribe active)")
+
+            # Stream audio to client
+            # yield (rate, chunk_array.reshape(1, -1))
+            msg = f"Chunk {i}/{total_chunks}"
+            yield ( (rate, chunk_array.reshape(1, -1)), AdditionalOutputs(msg) )
+            process_ms = (time.perf_counter() - iter_start) * 1000
+            # time.sleep(max(chunk_seconds - (process_ms / 1000.0) - 0.1, 0.01))
+            time.sleep(chunk_seconds)
+            raise_function()
+        logging.info(f"[{session_id}] Streaming completed successfully.")
+
+    except Exception as e:
+        logging.error(f"[{session_id}] Stream error: {e}", exc_info=True)
+    finally:
+        unregister_session(session_id)
+        clear_stop_flag(session_id)
+        if os.path.exists(progress_path):
+            os.remove(progress_path)
+        yield (None, AdditionalOutputs("STREAM_DONE"))
+
+
+# --------------------------------------------------------
+# TRANSCRIPTION
+# --------------------------------------------------------
+@spaces.GPU
+def transcribe(session_id: str):
+    """Continuously read and delete .npz chunks while transcription is active."""
+    active_flag = os.path.join(TMP_DIR, f"transcribe_active_{session_id}.txt")
+    with open(active_flag, "w") as f:
+        f.write("1")
+    logging.info(f"[{session_id}] Transcription started.")
+    chunk_dir = os.path.join(TMP_DIR, f"chunks_{session_id}")
+
+
+    try:
+        logging.info(f"[{session_id}] Transcription loop started.")
+        while os.path.exists(active_flag):
+            if not os.path.exists(chunk_dir):
+                logging.warning(f"[{session_id}] No chunk directory found for transcription.")
+                time.sleep(0.25)
+                continue
+            files = sorted(f for f in os.listdir(chunk_dir) if f.endswith(".npz"))
+            if not files:
+                time.sleep(0.25)
+                continue
+
+            for fname in files:
+                fpath = os.path.join(chunk_dir, fname)
+                try:
+                    npz = np.load(fpath)
+                    samples = npz["data"]
+                    rate = int(npz["rate"])
+
+                    text = f"Transcribed {fname}: {len(samples)} samples @ {rate}Hz"
+                    logging.debug(f"[{session_id}] {text}")
+
+                    os.remove(fpath)
+                    logging.debug(f"[{session_id}] Deleted processed chunk: {fname}")
+                except Exception as e:
+                    logging.error(f"[{session_id}] Error processing {fname}: {e}")
+                    continue
+
+            time.sleep(0.25)
+            raise_function()
+        logging.info(f"[{session_id}] Transcription loop ended (flag removed).")
+
+    except Exception as e:
+        logging.error(f"[{session_id}] Transcription error: {e}", exc_info=True)
+    finally:
+        transcribe_active = os.path.join(TMP_DIR, f"transcribe_active_{session_id}.txt")
+        if os.path.exists(transcribe_active):
+            os.remove(transcribe_active)
+        logging.info(f"[{session_id}] Transcription stopped.")
+        try:
+            if os.path.exists(chunk_dir) and not os.listdir(chunk_dir):
+                os.rmdir(chunk_dir)
+                logging.debug(f"[{session_id}] Cleaned up empty chunk dir.")
+        except Exception as e:
+            logging.error(f"[{session_id}] Cleanup error: {e}")
+        logging.info(f"[{session_id}] Exiting transcription loop.")
+        return {
+            start_transcribe: gr.update(interactive=True),
+            stop_transcribe: gr.update(interactive=False),
+            progress_text: gr.update(value="🛑 Transcription stopped."),
+        }
+
+
+# --------------------------------------------------------
+# STOP STREAMING
+# --------------------------------------------------------
+# def stop_streaming(session_id: str):
+#     create_stop_flag(session_id)
+#     logging.info(f"[{session_id}] Stop button clicked → stop flag created.")
+#     return None
+
+
+def get_session_progress(session_id: str):
+    """Read streaming progress and return slider position + elapsed time."""
+    progress_path = os.path.join(TMP_DIR, f"progress_{session_id}.json")
+    if not os.path.exists(progress_path):
+        return 0.0, "00:00:00"
+    try:
+        with open(progress_path, "r") as f:
+            data = json.load(f)
+        value = data.get("value", 0.0)
+        elapsed = data.get("elapsed", "00:00:00")
+        return value, elapsed
+    except Exception:
+        return 0.0, "00:00:00"
+
+
+def handle_additional_outputs(message):
+    """Called each time a new AdditionalOutputs is received."""
+    logging.debug(f"📡 Additional output received: {message}")
+
+    if message == "STREAM_DONE":
+        return "✅ Streaming finished"
+    elif message:
+        return f"📡 {message}"
+    else:
+        return ""
+
+# --------------------------------------------------------
+# UI
+# --------------------------------------------------------
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "## 🎧 WebRTC Audio Streamer (Multi-user)\n"
+        "Each user controls their own stream. Transcription runs only during streaming."
+    )
+
+    session_id = gr.State() 
+    sid_box = gr.Textbox(label="Session ID", interactive=False)
+    demo.load(fn=on_load, inputs=None, outputs=[session_id, sid_box])
+    demo.unload(on_unload)
+    active_filepath = gr.State(value=DEFAULT_FILE)
+
+    with gr.Row(equal_height=True):
+        with gr.Column(elem_id="column_source", scale=1):
+            with gr.Group(elem_id="centered_content"):
+                main_audio = gr.Audio(
+                    label="Audio Source",
+                    sources=["upload", "microphone"],
+                    type="filepath",
+                    value=DEFAULT_FILE,
+                )
+
+                chunk_slider = gr.Slider(
+                    label="Chunk Duration (seconds)",
+                    minimum=0.5,
+                    maximum=5.0,
+                    value=1.0,
+                    step=0.5,
+                    interactive=True,
+                )
+
+                progress_bar = gr.Slider(
+                    label="Streaming Progress (%)",
+                    minimum=0,
+                    maximum=100,
+                    value=0,
+                    step=0.1,
+                    interactive=False,
+                    visible=False,
+                )
+
+                progress_text = gr.Textbox(
+                    label="Elapsed Time (hh:mm:ss)",
+                    interactive=False,
+                    visible=False,
+                )
+
+                with gr.Row():
+                    start_button = gr.Button("▶️ Start Streaming", variant="primary")
+                    stop_button = gr.Button("⏹️ Stop Streaming", variant="stop", interactive=False)
+
+        with gr.Column():
+            status_box = gr.Textbox(label="Status", interactive=False)
+            webrtc_stream = WebRTC(
+                label="Audio Stream",
+                mode="receive",
+                modality="audio",
+                rtc_configuration=generate_coturn_config(),
+                visible=True,
+
+                
+            )
+            
+
+            
+    # --- Transcription Controls ---
+    with gr.Row(equal_height=True):
+         with gr.Column():
+            start_transcribe = gr.Button("🎙️ Start Transcribe", interactive=False)
+            stop_transcribe = gr.Button("🛑 Stop Transcribe", interactive=False)
+
+    # --- UI Logic ---
+    def start_streaming(session_id):
+        return {
+            start_button: gr.update(interactive=False),
+            stop_button: gr.update(interactive=True),
+            start_transcribe: gr.update(interactive=True),
+            stop_transcribe: gr.update(interactive=False),
+            chunk_slider: gr.update(interactive=False),
+            main_audio: gr.update(visible=False),
+            progress_bar: gr.update(value=0, visible=True),
+            progress_text: gr.update(value="00:00:00", visible=True),
+        }
+
+    def stop_streaming(session_id):
+        logging.debug(f"[{session_id}] UI: Stop clicked → restoring controls.")
+        create_stop_flag(session_id)
+        return {
+            webrtc_stream : None,
+            start_button: gr.update(interactive=True),
+            stop_button: gr.update(interactive=False),
+            start_transcribe: gr.update(interactive=False),
+            stop_transcribe: gr.update(interactive=False),
+            chunk_slider: gr.update(interactive=True),
+            main_audio: gr.update(visible=True),
+            progress_bar: gr.update(value=0, visible=False),
+            progress_text: gr.update(value="00:00:00", visible=False),
+        }
+    
+    ui_components = [
+        start_button, stop_button, start_transcribe, stop_transcribe,
+        chunk_slider, main_audio, progress_bar, progress_text,
+    ]
+    # --- Streaming event ---
+    webrtc_stream.stream(
+        fn=read_and_stream_audio,
+        inputs=[active_filepath, session_id, chunk_slider],
+        outputs=[webrtc_stream ],
+        trigger=start_button.click,
+        concurrency_limit=20,
+        concurrency_id="receive",
+    )
+    webrtc_stream.on_additional_outputs(
+        fn=handle_additional_outputs,
+        outputs=[status_box],
+    )
+    # status_box.change(
+    #     fn=update_status,
+    #     inputs=[status_box],
+    #     outputs=[status_box],
+    # )
+    # .then(
+    #     fn=stop_streaming,
+    #     inputs=[session_id],
+    #     outputs=ui_components
+    # )
+
+ 
+    start_button.click(fn=start_streaming, inputs=[session_id], outputs=ui_components)
+    # .then(fn=stop_streaming, inputs=[session_id], outputs=[webrtc_stream] + ui_components)
+    
+    stop_button.click(fn=stop_streaming, inputs=[session_id], outputs=[webrtc_stream] + ui_components)
+
+
+
+
+
+
+    # --- Transcription control logic ---
+    def start_transcribe_ui(session_id: str):
+        """Create transcription flag and update UI."""
+        return {
+            start_transcribe: gr.update(interactive=False),
+            stop_transcribe: gr.update(interactive=True),
+            progress_text: gr.update(value="🎙️ Transcription started..."),
+        }
+
+    def stop_transcribe_ui(session_id: str):
+        """Stop transcription by removing flag and update UI."""
+        transcribe_active = os.path.join(TMP_DIR, f"transcribe_active_{session_id}.txt")
+        if os.path.exists(transcribe_active):
+            os.remove(transcribe_active)
+        return {
+            start_transcribe: gr.update(interactive=True),
+            stop_transcribe: gr.update(interactive=False),
+            progress_text: gr.update(value="🛑 Transcription stopped."),
+        }
+
+
+    start_transcribe.click(
+    fn=start_transcribe_ui,
+    inputs=[session_id],
+    outputs=[start_transcribe, stop_transcribe, progress_text],
+    # --- then chain the transcription process ---
+    ).then(
+        fn=transcribe,
+        inputs=[session_id],
+        outputs=[start_transcribe, stop_transcribe, progress_text],
+    )
+
+    stop_transcribe.click(
+        fn=stop_transcribe_ui,
+        inputs=[session_id],
+        outputs=[start_transcribe, stop_transcribe, progress_text],
+    )
+
+    # --- Active sessions ---
+    with gr.Accordion("📊 Active Sessions", open=False):
+        sessions_table = gr.DataFrame(
+            headers=["session_id", "file", "start_time", "status"],
+            interactive=False,
+            wrap=True,
+            max_height=200,
+        )
+
+    gr.Timer(3.0).tick(fn=get_active_sessions, outputs=sessions_table)
+    gr.Timer(1.0).tick(fn=get_session_progress, inputs=[session_id], outputs=[progress_bar, progress_text])
+
+# --------------------------------------------------------
+# CSS
+# --------------------------------------------------------
+custom_css = """
+#column_source {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    gap: 1rem;
+    margin-top: auto;
+    margin-bottom: auto;
+}
+#column_source .gr-row {
+    padding-top: 12px;
+    padding-bottom: 12px;
+}
+"""
+demo.css = custom_css
+
+
+# --------------------------------------------------------
+# MAIN
+# --------------------------------------------------------
+if __name__ == "__main__":
+
+    demo.queue(max_size=20, api_open=False).launch(show_api=False, debug=True)