Updates UI state error

app.py

@@ -27,6 +27,7 @@ from app.utils import (
     generate_coturn_config,
     read_and_stream_audio,
     stop_streaming,
+    raise_error
 )
 from app.session_utils import (
     on_load,
@@ -102,6 +103,8 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
             main_audio.change(fn=on_file_load, inputs=[main_audio], outputs=ui_components_oload_audio)
 
             go_to_config.click(lambda: gr.Walkthrough(selected=1), outputs=walkthrough)
+            
+
 
         # === STEP 2 ===
         with gr.Step("Configuration", id=1)as config_step: 
@@ -125,7 +128,7 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
                     with gr.Row():
                         gr.Markdown("##### Decoding ")
                     with gr.Row():
-                        streaming_policy = gr.Dropdown(["waitk", "alignatt"], value="waitk", label="streaming_policy",  elem_classes="full-width",
+                        streaming_policy = gr.Dropdown(["waitk", "alignatt"], value="alignatt", label="streaming_policy",  elem_classes="full-width",
                                                            info="“Wait-k: Higher accuracy, requires larger left context, higher latency” \n”AlignAtt: Lower latency, suitable for production, predicts multiple tokens per chunk”")
                 
                     with gr.Row():
@@ -215,6 +218,7 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
                             height=150,
                             show_label=False
                         )
+
                         status_slider = gr.Slider(
                             0, 100,
                             value=0,
@@ -226,6 +230,7 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
                         )
                 start_stream_button = gr.Button("▶️ Start Streaming", variant="primary")
                 stop_stream_button = gr.Button("⏹️ Stop Streaming", visible=False,variant="stop")
+     
                 webrtc_stream.stream(
                     fn=read_and_stream_audio,
                     inputs=[active_filepath, session_hash_code,gr.State(READ_SIZE)],

app/ui_utils.py

@@ -6,8 +6,9 @@ import os
 from app.utils import (
     remove_active_task_flag_file,
     task_fake,
-    is_active_task
-    # task
+    is_active_task,
+    is_active_stream,
+    task
 )
 
 # from app.utils import (
@@ -27,7 +28,7 @@ DEFAULT_CONFIG = {
     "chunk_secs": 1.0,
     "left_context_secs": 20.0,
     "right_context_secs": 0.5,
-    "streaming_policy": "waitk",
+    "streaming_policy": "alignatt",
     "alignatt_thr": 8,
     "waitk_lagging": 2,
     "exclude_sink_frames": 8,
@@ -138,68 +139,163 @@ def summarize_config(
 
 def handle_additional_outputs(webrtc_stream, msg):
     """
-    Update UI elements based on streaming progress or errors.
-    Controls button states, audio visibility, and progress slider.
+    Updates UI elements based on streaming state.
+    
+    Improvements:
+    - Uses centralized state logic to avoid code duplication.
+    - Handles default values to reduce 'if/else' complexity.
+    - Secures reading of dictionary keys.
     """
-    # logging.debug(f"Additional output received: {msg}")
-    # ui_components = [start_stream_button, stop_stream_button,start_task_button,go_to_task, audio_source_step, status_slider,walkthrough]
+    
+    # 1. Default state initialization (Neutral or State Conservation Mode)
+    # By default, return gr.update() which means "do nothing"
+    # This avoids specifying the state of every button each time
+    start_btn = gr.update()
+    stop_btn = gr.update()
+    start_task_btn = gr.update()
+    go_to_task_btn = gr.update()
+    audio_step = gr.update()
+    slider = gr.update()
+    walkthrough = gr.update()
+    status_msg = gr.update(visible=False, value="")
+
+    # Safety: if msg is not a valid dictionary
+    if not isinstance(msg, dict):
+        return (start_btn, stop_btn, start_task_btn, go_to_task_btn, audio_step, slider, walkthrough, status_msg)
+
+    session_hash = msg.get("session_hash_code", "")
+
+    # --- CASE 1: ERROR ---
+    if msg.get("errored"):
+        error_val = msg.get("value", "Unknown error")
+        logging.error(f"[stream_ui] Client-side error: {error_val}")
+        
+        start_btn = gr.update(visible=True)
+        stop_btn = gr.update(visible=False)
+        start_task_btn = gr.update(visible=False)
+        go_to_task_btn = gr.update(visible=False)
+        audio_step = gr.update(interactive=True)
+        slider = gr.update(visible=False, value=0)
+        status_msg = gr.update(value=f"⚠️ **Error:** {error_val}", visible=True)
+
+    # --- CASE 2: MANUAL STOP ---
+    # Note: Kept key "stoped" (with one p), but added "stopped" just in case backend is fixed
+    elif msg.get("stoped") or msg.get("stopped"):
+        start_btn = gr.update(visible=True)
+        stop_btn = gr.update(visible=False)
+        start_task_btn = gr.update(visible=False)
+        go_to_task_btn = gr.update(visible=False)
+        audio_step = gr.update(interactive=True)
+        slider = gr.update(visible=True, value=0)
+        status_msg = gr.update(value="ℹ️ Stream stopped by user.", visible=True)
+
+    # --- CASE 3: PROGRESS ---
+    elif msg.get("progressed"):
+        progress = float(msg.get("value", 0))
+        
+        # Common logic for progress (active or finished)
+        start_btn = gr.update(visible=False) # Hide Start during stream
+        stop_btn = gr.update(visible=True)   # Show Stop during stream
+        audio_step = gr.update(interactive=False) # Lock input
+        slider = gr.update(visible=True, value=progress)
+        
+        # Sub-case: Streaming finished (100%)
+        if progress >= 100.0:
+            start_btn = gr.update(visible=True)
+            stop_btn = gr.update(visible=False)
+            start_task_btn = gr.update(visible=False)
+            go_to_task_btn = gr.update(visible=True)
+            audio_step = gr.update(interactive=True)
+            # Status message remains hidden and empty (default values)
+        
+        # Sub-case: Streaming in progress (<100%)
+        else:
+            go_to_task_btn = gr.update(visible=True)
+            
+            # Your specific logic for start_task_button
+            # If task is active, do not touch (empty gr.update), otherwise show
+            if (not is_active_task(session_hash)) and is_active_stream(session_hash):
+                start_task_btn = gr.update(visible=True)
+            
+            # No status message during normal progress
+
+    # --- SINGLE RETURN ---
+    # Order must match EXACTLY your outputs=[...] list in Gradio
+    return (
+        start_btn,      # 1. start_stream_button
+        stop_btn,       # 2. stop_stream_button
+        start_task_btn, # 3. start_task_button
+        go_to_task_btn, # 4. go_to_task
+        audio_step,     # 5. audio_source_step
+        slider,         # 6. status_slider
+        walkthrough,    # 7. walkthrough
+        status_msg      # 8. status_message (Markdown/HTML)
+    )
+
+
+# def handle_additional_outputs(webrtc_stream, msg):
+#     """
+#     Update UI elements based on streaming progress or errors.
+#     Controls button states, audio visibility, and progress slider.
+#     """
+#     # ui_components = [start_stream_button, stop_stream_button,start_task_button,go_to_task, audio_source_step, status_slider,walkthrough]
 
-    progress = float(0)
-    # Handle structured error message
+#     progress = float(0)
+#     # Handle structured error message
 
-    if isinstance(msg, dict) and msg.get("errored"):
-        value = msg.get("value", "Unknown error.")
-        logging.error(f"[stream_ui] Client-side error: {value}")
+#     if isinstance(msg, dict) and msg.get("errored"):
+#         value = msg.get("value", "Unknown error.")
+#         logging.error(f"[stream_ui] Client-side error: {value}")
         
-        return (
-                gr.update(visible=True),   # start_stream_button enabled
-                gr.update(visible=False),  # stop_stream_button disabled
-                gr.update(visible=False),    #start_task_button
-                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
-                gr.update(),              #walkthrough
-                gr.update(value=f"**Error:** {value}", visible=True)
-            )
+#         return (
+#                 gr.update(visible=True),   # start_stream_button enabled
+#                 gr.update(visible=False),  # stop_stream_button disabled
+#                 gr.update(visible=False),    #start_task_button
+#                 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
+#                 gr.update(),              #walkthrough
+#                 gr.update(value=f"**Error:** {value}", visible=True)
+#             )
         
        
-    elif msg.get("progressed") :
-        value = msg.get("value", 0)
-        progress = float(value)
-        if progress == 100.00 :
-            return (
-                gr.update(visible=True),      # start_stream_button disabled
-                gr.update(visible=False),       # stop_stream_button enabled
-                gr.update(visible=False),    #start_task_button
-                gr.update(visible=True),  # go_to_task enabled
-                gr.update(interactive=True),          # hide audio_source_step
-                gr.update(visible=True, value=progress), # show progress
-                gr.update(),                             #walkthrough
-                gr.update(value="", visible=False) 
-            )
-        else :    
-            return (
-                gr.update(visible=False),      # start_stream_button disabled
-                gr.update(visible=True),       # stop_stream_button enabled
-                gr.update() if is_active_task(msg.get("session_hash_code")) else gr.update(visible=True),    #start_task_button
-                gr.update(visible=True),  # go_to_task enabled
-                gr.update(interactive=False),          # hide audio_source_step
-                gr.update(visible=True, value=progress), # show progress
-                gr.update(),                            #walkthrough
-                gr.update(value="", visible=False) 
-            )
-    elif msg.get("stoped") :
+#     elif msg.get("progressed") :
+#         value = msg.get("value", 0)
+#         progress = float(value)
+#         if progress == 100.00 :
+#             return (
+#                 gr.update(visible=True),      # start_stream_button disabled
+#                 gr.update(visible=False),       # stop_stream_button enabled
+#                 gr.update(visible=False),    #start_task_button
+#                 gr.update(visible=True),  # go_to_task enabled
+#                 gr.update(interactive=True),          # hide audio_source_step
+#                 gr.update(visible=True, value=progress), # show progress
+#                 gr.update(),                             #walkthrough
+#                 gr.update(value="", visible=False) 
+#             )
+#         else :    
+#             return (
+#                 gr.update(visible=False),      # start_stream_button disabled
+#                 gr.update(visible=True),       # stop_stream_button enabled
+#                 gr.update() if is_active_task(msg.get("session_hash_code")) else gr.update(visible=True),    #start_task_button
+#                 gr.update(visible=True),  # go_to_task enabled
+#                 gr.update(interactive=False),          # hide audio_source_step
+#                 gr.update(visible=True, value=progress), # show progress
+#                 gr.update(),                            #walkthrough
+#                 gr.update(value="", visible=False) 
+#             )
+#     elif msg.get("stoped") :
         
-        return (
-            gr.update(visible=True),      # start_stream_button disabled
-            gr.update(visible=False),       # stop_stream_button enabled
-            gr.update(visible=False),    #start_task_button
-            gr.update(visible=False),  # go_to_task enabled
-            gr.update(interactive=True),          # hide audio_source_step
-            gr.update(visible=True, value=0), # show progress
-            gr.update(),                       #walkthrough
-            gr.update(value="ℹStream stopped by user.", visible=True)
-        )
+#         return (
+#             gr.update(visible=True),      # start_stream_button disabled
+#             gr.update(visible=False),       # stop_stream_button enabled
+#             gr.update(visible=False),    #start_task_button
+#             gr.update(visible=False),  # go_to_task enabled
+#             gr.update(interactive=True),          # hide audio_source_step
+#             gr.update(visible=True, value=0), # show progress
+#             gr.update(),                       #walkthrough
+#             gr.update(value="ℹStream stopped by user.", visible=True)
+#         )
 
 
 
@@ -238,46 +334,125 @@ def get_custom_theme() :
 
 
 ########## task 
+# def start_task_asr_ast(
+#         session_hash_code,
+#         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
+#                 ):
+#     """Stream transcription or translation results in real time."""
+#     accumulated = ""
+#     # Boucle sur le générateur de `task2()`
+#     # outputs=[task_output,status_message_task,start_task_button,stop_task_button,config_step]
+#     for result, status, current_chunk in task_fake(
+#         session_hash_code,
+#         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 status == "success":
+#             yield (accumulated + result, #task_output
+#                 gr.update(visible=True,value=current_chunk,elem_classes=[status]),#status_message_task
+#                 gr.update(visible=False),#start_task_button
+#                 gr.update(visible=True), #stop_task_button
+#                 gr.update(interactive=False) # config_step
+#                 )
+#             accumulated += result
+#         elif status in ["warning","info" ]:
+#             yield (accumulated, #task_output
+#                     gr.update(visible=True,value=result , elem_classes=[status]),#status_message_task
+#                     gr.update(visible=False),#start_task_button
+#                     gr.update(visible=True),#stop_task_button
+#                     gr.update(interactive=False) # config_step
+#                 )
+#         elif status in [ "done"]:
+#             yield (accumulated, #task_output
+#                    gr.update(visible=True,value=result , elem_classes=[status]),#status_message_task
+#                    gr.update(visible=True) if is_active_stream(session_hash_code) else gr.update(visible=False),#start_task_button
+#                    gr.update(visible=False),#stop_task_button
+#                    gr.update(interactive=True) # config_step
+#             )
+
+
 def start_task_asr_ast(
+    session_hash_code,
+    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
+):
+    """
+    Manages streaming of transcription (ASR) or translation (AST) results.
+    Orchestrates real-time UI updates (text, status, buttons).
+    """
+    accumulated_text = ""
+    
+    # Call task generator (backend)
+    task_generator = task_fake(
         session_hash_code,
         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
-                ):
-    """Stream transcription or translation results in real time."""
-    accumulated = ""
-    # Boucle sur le générateur de `task2()`
-    # outputs=[task_output,status_message_task,start_task_button,stop_task_button,config_step]
-    for result, status, current_chunk in task_fake(
-        session_hash_code,
-        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
-        ):
+    )
+
+    # Loop over partial results
+    # result_data: can be transcribed text OR an info message depending on status
+    for result_data, status, debug_info in task_generator:
+        
+        # 1. Default states for this iteration ('In Progress' mode)
+        # By default, lock config and allow stopping
+        start_btn = gr.update(visible=False)
+        stop_btn = gr.update(visible=True)
+        config_step = gr.update(interactive=False)
+        
+        # Status message and main text depend on return type
+        status_msg = gr.update(visible=True)
+        main_output = accumulated_text
+
+        # --- CASE 1: SUCCESS (New text segment) ---
         if status == "success":
-            yield (accumulated + result, #task_output
-                gr.update(visible=True,value=current_chunk,elem_classes=[status]),#status_message_task
-                gr.update(visible=False),#start_task_button
-                gr.update(visible=True), #stop_task_button
-                gr.update(interactive=False) # config_step
-                )
-            accumulated += result
-        elif status in ["warning","info" ]:
-            yield (accumulated, #task_output
-                    gr.update(visible=True,value=result , elem_classes=[status]),#status_message_task
-                    gr.update(visible=False),#start_task_button
-                    gr.update(visible=True),#stop_task_button
-                    gr.update(interactive=False) # config_step
-                )
-        elif status in [ "done"]:
-            yield (accumulated, #task_output
-                   gr.update(visible=True,value=result , elem_classes=[status]),#status_message_task
-                   gr.update(visible=True),#start_task_button
-                   gr.update(visible=False),#stop_task_button
-                   gr.update(interactive=True) # config_step
-            )
+            # result_data is the new text chunk here
+            partial_text = result_data
+            
+            # Update accumulator
+            accumulated_text += partial_text
+            main_output = accumulated_text
+            
+            # Status message displays chunk info (e.g., timestamps)
+            status_msg = gr.update(visible=True, value=debug_info, elem_classes=[status])
+
+        # --- CASE 2: WARNING / INFO (System message) ---
+        elif status in ["warning", "info"]:
+            # result_data is the error or info message here
+            # Do not touch accumulated_text
+            status_msg = gr.update(visible=True, value=result_data, elem_classes=[status])
+
+
+        # --- CASE 3: DONE / ERROR---
+        elif status in ["done", "error"]:
+            logging.error(f"[ui] error ")
+            # Re-enable controls
+            is_streaming = is_active_stream(session_hash_code)
+            start_btn = gr.update(visible=is_streaming) # Show Start only if audio stream is active
+            stop_btn = gr.update(visible=False)
+            config_step = gr.update(interactive=True)
+            
+            # result_data is the completion message
+            status_msg = gr.update(visible=True, value=result_data, elem_classes=[status])
+
+        # 2. Single dispatch to UI
+        # Expected order: [task_output, status_message_task, start_task_button, stop_task_button, config_step]
+        yield (
+            main_output,
+            status_msg,
+            start_btn,
+            stop_btn,
+            config_step
+        )
+
 
 def stop_task_fn(session_hash_code):
     remove_active_task_flag_file(session_hash_code)

app/utils.py

@@ -5,7 +5,7 @@ import asyncio
 import os
 import time
 import numpy as np
-
+import zipfile
 import spaces
 import hmac
 import hashlib
@@ -96,7 +96,6 @@ def read_and_stream_audio(filepath_to_stream: str, session_hash_code: str,read_s
         logging.info(f"[{session_hash_code}] Starting stream: {filepath_to_stream} ({total_chunks} chunks, {chunk_duration_ms}ms steps).")
 
         chunk_dir = get_session_hashe_chunks_dir(session_hash_code)
-        ensure_dir_exists = False
         for i, start_ms in enumerate(range(0, total_duration_ms, chunk_duration_ms)):
             
 
@@ -130,19 +129,20 @@ def read_and_stream_audio(filepath_to_stream: str, session_hash_code: str,read_s
                 AdditionalOutputs({"progressed": True, "value": progress, "session_hash_code": session_hash_code})
             )
             if is_active_task(session_hash_code):
-                if not ensure_dir_exists:
-                    os.makedirs(chunk_dir, exist_ok=True)
-                    ensure_dir_exists = True
+                os.makedirs(chunk_dir, exist_ok=True)
                 
                 npz_path = os.path.join(chunk_dir, f"chunk_{i:05d}.npz")
                 # Compression activée, attention c'est lent (CPU intensif)
                 if is_active_task(session_hash_code):
-                    np.savez_compressed(npz_path, data=samples_int16, rate=frame_rate)
-                    logging.debug(f"[{session_hash_code}] Saved chunk {i} to {npz_path}")
+                    try :
+                        np.savez_compressed(npz_path, data=samples_int16, rate=frame_rate)
+                        logging.debug(f"[{session_hash_code}] Saved chunk {i} to {npz_path}")
+                    except Exception as e :
+                        logging.error(f"[{session_hash_code}] eroor in Saved chunk {i} to {npz_path}")
 
             time.sleep(chunk_duration_ms/1000)
 
-            raise_error()  # Optional injected test exception
+            # raise_error()  # Optional injected test exception
 
         logging.info(f"[{session_hash_code}] Streaming completed.")
 
@@ -150,6 +150,7 @@ def read_and_stream_audio(filepath_to_stream: str, session_hash_code: str,read_s
         yield from handle_stream_error(session_hash_code, e)
     finally:
         remove_active_stream_flag_file(session_hash_code)
+        remove_active_task_flag_file(session_hash_code)
         logging.info(f"[{session_hash_code}] Cleanup done.")
 
 
@@ -211,13 +212,13 @@ def task_fake(session_hash_code: str,
         logging.info(f"[{session_hash_code}] task loop started.")
         yield (f"Task started for session {session_hash_code}", "info", None)
         
-        while os.path.exists(active_flag):
+        while os.path.exists(active_flag) :
             if not os.path.exists(chunk_dir):
                 logging.warning(f"[{session_hash_code}] No chunk directory found for task.")
                 yield ("No audio chunks yet... waiting for stream.", "warning", None)
                 time.sleep(0.1)
                 continue
-                
+            # raise_error()    
             files = sorted(f for f in os.listdir(chunk_dir) if f.endswith(".npz"))
             if not files:
                 time.sleep(0.1)
@@ -233,15 +234,16 @@ def task_fake(session_hash_code: str,
                     yield (text, "success", fname)   
                     os.remove(fpath)
                     logging.debug(f"[{session_hash_code}] Deleted processed chunk: {fname}")
-                    # raise_error()
+                    # raise_error() 
 
-                except EOFError as e:
-                    logging.warning(f"[{session_hash_code}] Error processing {fname}: {e}")
+                except (EOFError, OSError, zipfile.BadZipFile, ValueError) as e:
+                    logging.warning(f"[{session_hash_code}] warning processing {fname}: {e}")
                     yield (f"EOFError processing {fname}: {e}", "warning", fname)
                 except Exception as e:
-                    logging.warning(f"[{session_hash_code}] Error processing {fname}: {e}")
-                    yield (f"Error processing {fname}: {e}", "warning", fname)
-                   
+                    error_type = type(e).__name__ 
+                    logging.error(f"[{session_hash_code}] Error processing {fname}: {e} {error_type}")
+                    # yield (f"Error processing {fname}: {e}", "error", fname)
+                    raise Exception(e)
                     # continue
                 time.sleep(0.1)
                 
@@ -249,8 +251,9 @@ def task_fake(session_hash_code: str,
         logging.info(f"[{session_hash_code}] task loop ended (flag removed).")
         
     except Exception as e:
-        logging.error(f"[{session_hash_code}] task error: {e}", exc_info=True)
+        logging.error(f"[{session_hash_code}] Unexpected task error: {e}", exc_info=True)
         yield (f"Unexpected error: {e}", "error", None)
+        return
         
     finally:
         if os.path.exists(active_flag):
@@ -266,7 +269,7 @@ def task_fake(session_hash_code: str,
             yield (f"Cleanup error: {e}", "error", None)
             
         logging.info(f"[{session_hash_code}] Exiting task loop.")
-        yield ("Task finished and cleaned up.", "done", None)
+        # yield ("Task finished and cleaned up.", "done", None)
 
 
 @spaces.GPU
@@ -406,6 +409,10 @@ def is_active_task(session_hash_code) -> bool:
     """Check if the stop signal was requested."""
     return os.path.exists(get_active_task_flag_file(session_hash_code))
 
+def is_active_stream(session_hash_code) -> bool:
+    """Check if the stop signal was requested."""
+    return os.path.exists(get_active_stream_flag_file(session_hash_code))
+
 
 def raise_error():
     """Raise an error randomly (1 out of 10 times)."""

assets/custom_style.css

@@ -156,7 +156,7 @@ body {
 }
 
 /* Le style .info (bleu) */
-#status-message-task.info{
+#status-message-task.info,#status-message-task.success,#status-message-task.done{
     color: #0c5464; /* Texte bleu foncé */
     background-color: #d1ecf1; /* Fond bleu clair */
     border-color: #bee5eb; /* Bordure bleue */