Refactor: Replace session_hash with session_hash_code

app.py

@@ -22,9 +22,9 @@ from app.utils import (
 from app.session_utils import (
     on_load,
     on_unload,
-    get_active_sessions_hash,
-    register_session_hash,
-    reset_all_active_sessions_hash,
+    get_active_session_hash_code,
+    register_session_hash_code,
+    reset_all_active_session_hash_code,
     get_active_task_flag_file,
     
 )
@@ -43,23 +43,23 @@ from app.ui_utils import (
 # --------------------------------------------------------
 # Initialization
 # --------------------------------------------------------
-reset_all_active_sessions_hash()
+reset_all_active_session_hash_code()
 
 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)
+    session_hash_code = gr.State()
+    session_hash_code_box = gr.Textbox(label="Session ID", interactive=False, visible=DEBUG)
     with gr.Accordion("📊 Active Sessions Hash", open=True ,visible=DEBUG):
         sessions_table = gr.DataFrame(
-            headers=["session_hash", "file", "start_time", "status"],
+            headers=["session_hash_code", "file", "start_time", "status"],
             interactive=False,
             wrap=True,
             max_height=200,
         )
-        gr.Timer(3.0).tick(fn=get_active_sessions_hash, outputs=sessions_table)
+        gr.Timer(3.0).tick(fn=get_active_session_hash_code, outputs=sessions_table)
 
-    demo.load(fn=on_load, inputs=None, outputs=[session_hash, session_hash_box])
+    demo.load(fn=on_load, inputs=None, outputs=[session_hash_code, session_hash_code_box])
     demo.unload(on_unload)
     stop_streaming_flags = gr.State(value={"stop": False})
     active_filepath = gr.State(value=next(iter(EXAMPLE_CONFIGS)))
@@ -125,7 +125,7 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
 
             webrtc_stream.stream(
                 fn=read_and_stream_audio,
-                inputs=[active_filepath, session_hash, stop_streaming_flags],
+                inputs=[active_filepath, session_hash_code, stop_streaming_flags],
                 outputs=[webrtc_stream],
                 trigger=start_stream_button.click,
                 concurrency_id="audio_stream",
@@ -242,12 +242,12 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
 
                     stop_stream_button.click(
                         fn=stop_streaming,
-                        inputs=[session_hash, stop_streaming_flags],
+                        inputs=[session_hash_code, stop_streaming_flags],
                         outputs=[stop_streaming_flags],
                     )
 
-                    def stop_task_fn(session_hash):
-                        transcribe_active = get_active_task_flag_file(session_hash)
+                    def stop_task_fn(session_hash_code):
+                        transcribe_active = get_active_task_flag_file(session_hash_code)
                         if os.path.exists(transcribe_active):
                             os.remove(transcribe_active)
                         yield "Task stopped by user."
@@ -255,13 +255,13 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
 
                     stop_task_button.click(
                         fn=stop_task_fn,
-                        inputs=session_hash,
+                        inputs=session_hash_code,
                         outputs=transcription_output
                     )
-                        # task(session_hash)
+                        # task(session_hash_code)
 
                     def start_transcription(
-                        session_hash, stop_streaming_flags,
+                        session_hash_code, stop_streaming_flags,
                         task_type, lang_source, lang_target,
                         chunk_secs, left_context_secs, right_context_secs,
                         streaming_policy, alignatt_thr, waitk_lagging,
@@ -273,7 +273,7 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
                         yield f"Starting {task_type.lower()}...\n\n",gr.update(visible=False),gr.update(visible=True)
 
                         # Boucle sur le générateur de `task()`
-                        for msg in task(session_hash):
+                        for msg in task(session_hash_code):
                             accumulated += msg
                             yield accumulated,gr.update(visible=False),gr.update(visible=True)
 
@@ -282,7 +282,7 @@ with gr.Blocks(theme=theme, css=css_style) as demo:
                     start_task_button.click(
                         fn=start_transcription,
                         inputs=[
-                            session_hash, stop_streaming_flags,
+                            session_hash_code, stop_streaming_flags,
                             task_type, lang_source, lang_target,
                             chunk_secs, left_context_secs, right_context_secs,
                             streaming_policy, alignatt_thr, waitk_lagging,

app/session_utils.py

@@ -8,7 +8,7 @@ import gradio as gr
 # TMP_DIR = "/tmp/canary_aed_streaming"
 
 TMP_DIR = os.getenv("TMP_DIR", "/tmp/canary_aed_streaming")
-ACTIVE_SESSIONS_HASH_FILE = os.path.join(TMP_DIR, "active_sessions_hash.json")
+ACTIVE_SESSIONS_HASH_FILE = os.path.join(TMP_DIR, "active_session_hash_code.json")
 ACTIVE_TASK_FLAG="task_active_"
 NAME_FOLDER_CHUNKS="chunks_"
 
@@ -16,7 +16,7 @@ NAME_FOLDER_CHUNKS="chunks_"
 # ---------------------------
 # Helper to manage the JSON
 # ---------------------------
-def _read_sessions_hash():
+def _read_session_hash_code():
     if not os.path.exists(ACTIVE_SESSIONS_HASH_FILE):
         return {}
     try:
@@ -26,7 +26,7 @@ def _read_sessions_hash():
         return {}
 
 
-def _write_sessions_hash(data):
+def _write_session_hash_code(data):
     os.makedirs(os.path.dirname(ACTIVE_SESSIONS_HASH_FILE), exist_ok=True)
     with open(ACTIVE_SESSIONS_HASH_FILE, "w") as f:
         json.dump(data, f, indent=2)
@@ -37,20 +37,20 @@ def _write_sessions_hash(data):
 # ---------------------------
 def on_load(request: gr.Request):
     """Called when a new visitor opens the app."""
-    session_hash = request.session_hash  
-    sessions = _read_sessions_hash()
+    session_hash_code = request.session_hash   
+    sessions = _read_session_hash_code()
 
-    sessions[session_hash] = {
-        "session_hash": session_hash,
+    sessions[session_hash_code] = {
+        "session_hash_code": session_hash_code,
         "file": "",
         "start_time": datetime.utcnow().strftime("%H:%M:%S"),
         "status": "active",
     }
 
-    _write_sessions_hash(sessions)
-    logging.info(f"[{session_hash}] session_hash registered (on_load).")
+    _write_session_hash_code(sessions)
+    logging.info(f"[{session_hash_code}] session_hash_code registered (on_load).")
 
-    return session_hash, session_hash  # can be used as gr.State + display
+    return session_hash_code, session_hash_code  # can be used as gr.State + display
 
 
 # ---------------------------
@@ -58,17 +58,17 @@ def on_load(request: gr.Request):
 # ---------------------------
 def on_unload(request: gr.Request):
     """Called when the visitor closes or refreshes the app."""
-    sid = request.session_hash
-    sessions = _read_sessions_hash()
+    sid = request.session_hash_code
+    sessions = _read_session_hash_code()
 
     if sid in sessions:
         sessions.pop(sid)
-        _write_sessions_hash(sessions)
-        remove_session_hash_data(sid)
-        unregister_session_hash_hash(sid)
-        logging.info(f"[{sid}] session_hash removed (on_unload).")
+        _write_session_hash_code(sessions)
+        remove_session_hash_code_data(sid)
+        unregister_session_hash_code_hash(sid)
+        logging.info(f"[{sid}] session_hash_code removed (on_unload).")
     else:
-        logging.info(f"[{sid}] No active session_hash found to remove.")
+        logging.info(f"[{sid}] No active session_hash_code found to remove.")
 
 def ensure_tmp_dir():
     """Ensures the base temporary directory exists."""
@@ -78,17 +78,17 @@ def ensure_tmp_dir():
         logging.error(f"Failed to create tmp directory {TMP_DIR}: {e}")
 
 
-def reset_all_active_sessions_hash():
-    """Removes all temporary session_hash files and folders at startup."""
+def reset_all_active_session_hash_code():
+    """Removes all temporary session_hash_code files and folders at startup."""
     ensure_tmp_dir()
 
     try:
-        # --- Remove active session_hashs file ---
+        # --- Remove active session_hash_codes file ---
         if os.path.exists(ACTIVE_SESSIONS_HASH_FILE):
             os.remove(ACTIVE_SESSIONS_HASH_FILE)
-            logging.info("Active session_hashs file reset at startup.")
+            logging.info("Active session_hash_codes file reset at startup.")
         else:
-            logging.debug("No active session_hashs file found to reset.")
+            logging.debug("No active session_hash_codes file found to reset.")
         # --- Clean all flag files (stream + transcribe) ---
         for f in os.listdir(TMP_DIR):
             if (
@@ -113,31 +113,31 @@ def reset_all_active_sessions_hash():
 
         logging.info("Temporary session cleanup completed successfully.")       
     except Exception as e:
-        logging.error(f"Error resetting active session_hashs: {e}")
+        logging.error(f"Error resetting active session_hash_codes: {e}")
 
-def remove_session_hash_data(session_hash: str):
-    """Removes all temporary files and data related to a specific session_hash."""
-    if not session_hash:
-        logging.warning("reset_session() called without a valid session_hash.")
+def remove_session_hash_code_data(session_hash_code: str):
+    """Removes all temporary files and data related to a specific session_hash_code."""
+    if not session_hash_code:
+        logging.warning("reset_session() called without a valid session_hash_code.")
         return
 
     try:
-        # --- Remove session_hash from active_sessions.json ---
+        # --- Remove session_hash_code from active_sessions.json ---
         if os.path.exists(ACTIVE_SESSIONS_HASH_FILE):
             try:
                 with open(ACTIVE_SESSIONS_HASH_FILE, "r") as f:
                     data = json.load(f)
-                if session_hash in data:
-                    data.pop(session_hash)
+                if session_hash_code in data:
+                    data.pop(session_hash_code)
                     with open(ACTIVE_SESSIONS_HASH_FILE, "w") as f:
                         json.dump(data, f, indent=2)
-                    logging.debug(f"[{session_hash}] Removed from {ACTIVE_SESSIONS_HASH_FILE}.")
+                    logging.debug(f"[{session_hash_code}] Removed from {ACTIVE_SESSIONS_HASH_FILE}.")
             except Exception as e:
-                logging.warning(f"[{session_hash}] Failed to update {ACTIVE_SESSIONS_HASH_FILE}: {e}")
+                logging.warning(f"[{session_hash_code}] Failed to update {ACTIVE_SESSIONS_HASH_FILE}: {e}")
 
-        # --- Define all possible session_hash file patterns ---
+        # --- Define all possible session_hash_code file patterns ---
         files_to_remove = [
-            get_active_task_flag_file(session_hash),
+            get_active_task_flag_file(session_hash_code),
         ]
 
         # --- Remove all temporary files ---
@@ -146,33 +146,33 @@ def remove_session_hash_data(session_hash: str):
             if os.path.exists(path):
                 try:
                     os.remove(path)
-                    logging.debug(f"[{session_hash}] Removed file: {fname}")
+                    logging.debug(f"[{session_hash_code}] Removed file: {fname}")
                 except Exception as e:
-                    logging.warning(f"[{session_hash}] Failed to remove file {fname}: {e}")
+                    logging.warning(f"[{session_hash_code}] Failed to remove file {fname}: {e}")
 
         # --- Remove chunk folder if exists ---
-        chunk_dir = os.path.join(TMP_DIR, f"chunks_{session_hash}")
+        chunk_dir = os.path.join(TMP_DIR, f"chunks_{session_hash_code}")
         if os.path.isdir(chunk_dir):
             try:
                 shutil.rmtree(chunk_dir)
-                logging.debug(f"[{session_hash}] Removed chunk folder: chunks_{session_hash}")
+                logging.debug(f"[{session_hash_code}] Removed chunk folder: chunks_{session_hash_code}")
             except Exception as e:
-                logging.warning(f"[{session_hash}] Failed to remove chunk folder: {e}")
+                logging.warning(f"[{session_hash_code}] Failed to remove chunk folder: {e}")
 
-        logging.info(f"[{session_hash}] session_hash fully reset.")
+        logging.info(f"[{session_hash_code}] session_hash_code fully reset.")
 
     except Exception as e:
-        logging.error(f"[{session_hash}] Error during reset_session: {e}")
+        logging.error(f"[{session_hash_code}] Error during reset_session: {e}")
 
 def generate_session_id() -> str:
-    """Generates a unique session_hash ID."""
+    """Generates a unique session_hash_code ID."""
     sid = str(uuid.uuid4())
-    logging.debug(f"[{sid}] New session_hash created.")
+    logging.debug(f"[{sid}] New session_hash_code created.")
     return sid
 
 
-def register_session_hash(session_hash: str, filepath: str):
-    """Registers a new session_hash."""
+def register_session_hash_code(session_hash_code: str, filepath: str):
+    """Registers a new session_hash_code."""
     ensure_tmp_dir()
     data = {}
     if os.path.exists(ACTIVE_SESSIONS_HASH_FILE):
@@ -182,8 +182,8 @@ def register_session_hash(session_hash: str, filepath: str):
             except Exception:
                 data = {}
 
-    data[session_hash] = {
-        "session_hash": session_hash,
+    data[session_hash_code] = {
+        "session_hash_code": session_hash_code,
         "file": filepath,
         "start_time": datetime.utcnow().strftime("%H:%M:%S"),
         "status": "active",
@@ -192,28 +192,28 @@ def register_session_hash(session_hash: str, filepath: str):
     with open(ACTIVE_SESSIONS_HASH_FILE, "w") as f:
         json.dump(data, f)
 
-    logging.debug(f"[{session_hash}] session_hash registered in active_sessions.json.")
+    logging.debug(f"[{session_hash_code}] session_hash_code registered in active_sessions.json.")
 
 
-def unregister_session_hash_hash(session_hash: str):
-    """Removes a session_hash from the registry."""
+def unregister_session_hash_code_hash(session_hash_code: str):
+    """Removes a session_hash_code from the registry."""
     if not os.path.exists(ACTIVE_SESSIONS_HASH_FILE):
         return
 
     try:
         with open(ACTIVE_SESSIONS_HASH_FILE, "r") as f:
             data = json.load(f)
-        if session_hash in data:
-            data.pop(session_hash)
+        if session_hash_code in data:
+            data.pop(session_hash_code)
             with open(ACTIVE_SESSIONS_HASH_FILE, "w") as f:
                 json.dump(data, f)
-            logging.debug(f"[{session_hash}] session_hash unregistered.")
+            logging.debug(f"[{session_hash_code}] session_hash_code unregistered.")
     except Exception as e:
-        logging.error(f"[{session_hash}] Error unregistering session_hash: {e}")
+        logging.error(f"[{session_hash_code}] Error unregistering session_hash_code: {e}")
 
 
-def get_active_sessions_hash():
-    """Returns active session_hashs as a list of rows for the DataFrame."""
+def get_active_session_hash_code():
+    """Returns active session_hash_codes as a list of rows for the DataFrame."""
     if not os.path.exists(ACTIVE_SESSIONS_HASH_FILE):
         return []
 
@@ -223,7 +223,7 @@ def get_active_sessions_hash():
 
         rows = [
             [
-                s.get("session_hash", ""),
+                s.get("session_hash_code", ""),
                 s.get("file", ""),
                 s.get("start_time", ""),
                 s.get("status", ""),
@@ -232,13 +232,13 @@ def get_active_sessions_hash():
         ]
         return rows
     except Exception as e:
-        logging.error(f"Error reading active session_hashs: {e}")
+        logging.error(f"Error reading active session_hash_codes: {e}")
         return []
 
 
-def get_active_task_flag_file(session_hash: str):
-    return  os.path.join(TMP_DIR, f"{ACTIVE_TASK_FLAG}{session_hash}.txt")
+def get_active_task_flag_file(session_hash_code: str):
+    return  os.path.join(TMP_DIR, f"{ACTIVE_TASK_FLAG}{session_hash_code}.txt")
 
 
-def get_folder_chunks(session_hash: str):
-     return os.path.join(TMP_DIR, f"{NAME_FOLDER_CHUNKS}{session_hash}")
+def get_folder_chunks(session_hash_code: str):
+     return os.path.join(TMP_DIR, f"{NAME_FOLDER_CHUNKS}{session_hash_code}")