Solucion de problemas con los botones de volver a grabar y restaurar original. Solucion de incongruencias en los dialogos de descargas e implementacion de internacionalizacion de la herramienta

interface/components/downloader.py

@@ -7,6 +7,7 @@ Uses @st.dialog modals to warn about incomplete labeling before download.
 import streamlit as st
 import pandas as pd
 import config
+from i18n import t
 from services.export_service import (
     export_single_image,
     export_full_session,
@@ -22,134 +23,152 @@ def _get_image_missing_info(img: dict) -> list[str]:
     """Return a list of human-readable items that are missing for one image."""
     missing = []
     if img.get("label") is None:
-        missing.append("Etiqueta categórica")
+        missing.append(t("missing_categorical"))
     elif img["label"] == "Cataract":
         locs = img.get("locs_data", {})
         for field in config.LOCS_FIELDS:
             fid = field["field_id"]
             if fid not in locs:
-                missing.append(f"LOCS III – {field['label']}")
+                missing.append(t("missing_locs", field=field["label"]))
     if not img.get("transcription"):
-        missing.append("Etiquetado por voz")
+        missing.append(t("missing_voice"))
     return missing
 
 
 # ── Dialog: individual download with incomplete labeling ─────────────────────
 
-@st.dialog("⚠️ Etiquetado incompleto", dismissible=False)
 def _show_single_incomplete_dialog(image_id: str):
     """Warn about missing labeling for one image before individual download."""
-    img = st.session_state.images.get(image_id)
-    if img is None:
-        st.rerun()
-        return
 
-    missing = _get_image_missing_info(img)
-    if not missing:
-        st.session_state.pop("_pending_single_dl", None)
-        st.rerun()
-        return
-
-    st.markdown(
-        f"La imagen **{img['filename']}** tiene campos sin completar:"
-    )
-    for item in missing:
-        st.markdown(f"- {item}")
-
-    st.divider()
-    c1, c2 = st.columns(2)
-    with c1:
-        zip_bytes, zip_name = export_single_image(image_id)
-        if st.download_button(
-            label="⬇️ Descargar igualmente",
-            data=zip_bytes,
-            file_name=zip_name,
-            mime="application/zip",
-            key="_dlg_dl_single_anyway",
-            use_container_width=True,
-        ):
-            st.session_state.pop("_pending_single_dl", None)
+    @st.dialog(t("dlg_single_incomplete"), dismissible=False)
+    def _dlg():
+        img = st.session_state.images.get(image_id)
+        if img is None:
             st.rerun()
-    with c2:
-        if st.button(
-            "🔙 Regresar y terminar",
-            use_container_width=True,
-            type="primary",
-        ):
+            return
+
+        missing = _get_image_missing_info(img)
+        if not missing:
             st.session_state.pop("_pending_single_dl", None)
             st.rerun()
+            return
+
+        st.markdown(
+            t("incomplete_fields_msg", filename=img['filename'])
+        )
+        for item in missing:
+            st.markdown(f"- {item}")
+
+        st.divider()
+        c1, c2 = st.columns(2)
+        with c1:
+            zip_bytes, zip_name = export_single_image(image_id)
+            if st.download_button(
+                label=t("download_anyway"),
+                data=zip_bytes,
+                file_name=zip_name,
+                mime="application/zip",
+                key="_dlg_dl_single_anyway",
+                use_container_width=True,
+            ):
+                st.session_state.pop("_pending_single_dl", None)
+                st.rerun()
+        with c2:
+            if st.button(
+                t("go_back_finish"),
+                use_container_width=True,
+                type="primary",
+            ):
+                st.session_state.pop("_pending_single_dl", None)
+                st.rerun()
+
+    _dlg()
 
 
 # ── Dialog: bulk download with incomplete images ─────────────────────────────
 
-@st.dialog("⚠️ Imágenes con etiquetado incompleto", width="large", dismissible=False)
 def _show_bulk_incomplete_dialog():
     """Table showing per-image what labeling is missing before bulk download."""
-    images = st.session_state.images
-    order = st.session_state.image_order
-
-    # Build table data
-    rows = []
-    for img_id in order:
-        img = images[img_id]
-        has_categorical = img.get("label") is not None
-        needs_locs = img.get("label") == "Cataract"
-        locs = img.get("locs_data", {})
 
-        if needs_locs:
-            locs_filled = all(
-                f["field_id"] in locs for f in config.LOCS_FIELDS
-            )
-        else:
-            locs_filled = True  # Not applicable
-
-        has_voice = bool(img.get("transcription"))
-
-        # Only show images that have something missing
-        if not (has_categorical and locs_filled and has_voice):
-            rows.append({
-                "Imagen": img["filename"],
-                "Categórica": "✅" if has_categorical else "❌",
-                "LOCS III": (
-                    "✅" if locs_filled else "❌"
-                ) if needs_locs else "N/A",
-                "Voz": "✅" if has_voice else "❌",
-            })
-
-    if not rows:
-        st.session_state.pop("_pending_bulk_dl", None)
-        st.rerun()
-        return
-
-    st.markdown(
-        f"**{len(rows)} imagen(es)** tienen etiquetado incompleto:"
-    )
-    df = pd.DataFrame(rows)
-    st.dataframe(df, use_container_width=True, hide_index=True)
-
-    st.divider()
-    c1, c2 = st.columns(2)
-    with c1:
-        zip_bytes, zip_name = export_full_session()
-        if st.download_button(
-            label="⬇️ Descargar igualmente",
-            data=zip_bytes,
-            file_name=zip_name,
-            mime="application/zip",
-            key="_dlg_dl_bulk_anyway",
-            use_container_width=True,
-        ):
-            st.session_state.session_downloaded = True
-            st.session_state.pop("_pending_bulk_dl", None)
-            st.rerun()
-    with c2:
-        if st.button(
-            "🔙 Regresar y terminar",
-            use_container_width=True,
-            type="primary",
-        ):
+    @st.dialog(t("dlg_bulk_incomplete"), width="large", dismissible=False)
+    def _dlg():
+        images = st.session_state.images
+        order = st.session_state.image_order
+
+        # Build table data
+        rows = []
+        for img_id in order:
+            img = images[img_id]
+            has_categorical = img.get("label") is not None
+            needs_locs = img.get("label") == "Cataract"
+            locs = img.get("locs_data", {})
+
+            if needs_locs:
+                locs_filled = all(
+                    f["field_id"] in locs for f in config.LOCS_FIELDS
+                )
+            else:
+                locs_filled = True  # Not applicable
+
+            has_voice = bool(img.get("transcription"))
+
+            # Determine LOCS III column value:
+            #   - Cataract selected, all filled → ✅
+            #   - Cataract selected, missing fields → ❌
+            #   - No label selected → ❌
+            #   - Non-cataract label selected → "Not Required"
+            if needs_locs:
+                locs_cell = "✅" if locs_filled else "❌"
+            elif has_categorical:
+                locs_cell = t("locs_not_required")
+            else:
+                locs_cell = "❌"
+
+            # Only show images that have something missing
+            if not (has_categorical and locs_filled and has_voice):
+                rows.append({
+                    t("col_image"): img["filename"],
+                    t("col_categorical"): "✅" if has_categorical else "❌",
+                    t("col_locs"): locs_cell,
+                    t("col_voice"): "✅" if has_voice else "❌",
+                })
+
+        if not rows:
             st.session_state.pop("_pending_bulk_dl", None)
             st.rerun()
+            return
+
+        st.markdown(
+            t("bulk_incomplete_msg", count=len(rows))
+        )
+        df = pd.DataFrame(rows)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+
+        st.divider()
+        c1, c2 = st.columns(2)
+        with c1:
+            zip_bytes, zip_name = export_full_session()
+            if st.download_button(
+                label=t("download_anyway"),
+                data=zip_bytes,
+                file_name=zip_name,
+                mime="application/zip",
+                key="_dlg_dl_bulk_anyway",
+                use_container_width=True,
+            ):
+                st.session_state.session_downloaded = True
+                st.session_state.pop("_pending_bulk_dl", None)
+                st.rerun()
+        with c2:
+            if st.button(
+                t("go_back_finish"),
+                use_container_width=True,
+                type="primary",
+            ):
+                st.session_state.pop("_pending_bulk_dl", None)
+                st.rerun()
+
+    _dlg()
 
 
 # ── Main downloader ──────────────────────────────────────────────────────────
@@ -173,14 +192,14 @@ def render_downloader(image_id: str):
     col_dl, col_info = st.columns(2)
 
     with col_dl:
-        st.subheader("📥 Descarga individual")
+        st.subheader(t("single_download"))
 
         # Check completeness for individual download
         missing = _get_image_missing_info(img)
         if missing:
             # Show button that triggers the warning dialog
             if st.button(
-                f"⬇️ Descargar — {img['filename']}",
+                t("download_file", filename=img['filename']),
                 key=f"dl_single_check_{image_id}",
                 use_container_width=True,
             ):
@@ -189,7 +208,7 @@ def render_downloader(image_id: str):
         else:
             zip_bytes, zip_name = export_single_image(image_id)
             st.download_button(
-                label=f"⬇️ Descargar — {img['filename']}",
+                label=t("download_file", filename=img['filename']),
                 data=zip_bytes,
                 file_name=zip_name,
                 mime="application/zip",
@@ -198,25 +217,25 @@ def render_downloader(image_id: str):
             )
 
     with col_info:
-        st.subheader("📊 Información de sesión")
+        st.subheader(t("session_info"))
         summary = get_session_summary()
         sc1, sc2 = st.columns(2)
         with sc1:
-            st.metric("Imágenes", summary["total"])
-            st.metric("Con audio", summary["with_audio"])
+            st.metric(t("images_metric"), summary["total"])
+            st.metric(t("with_audio"), summary["with_audio"])
         with sc2:
-            st.metric("Etiquetadas", f"{summary['labeled']} / {summary['total']}")
-            st.metric("Con transcripción", summary["with_transcription"])
+            st.metric(t("labeled_metric"), f"{summary['labeled']} / {summary['total']}")
+            st.metric(t("with_transcription"), summary["with_transcription"])
 
     st.divider()
 
     # ── Full-width: Bulk download ────────────────────────────────────────
-    st.subheader("📦 Descargar todo el etiquetado")
+    st.subheader(t("bulk_download"))
 
     summary = get_session_summary()
 
     if summary["total"] == 0:
-        st.info("No hay imágenes para descargar.")
+        st.info(t("no_images_download"))
     else:
         # Check if any image has incomplete labeling
         has_incomplete = any(
@@ -226,7 +245,7 @@ def render_downloader(image_id: str):
 
         if has_incomplete:
             if st.button(
-                "⬇️ Descargar todo el etiquetado (ZIP)",
+                t("download_all_zip"),
                 key="dl_bulk_check",
                 use_container_width=True,
                 type="primary",
@@ -236,7 +255,7 @@ def render_downloader(image_id: str):
         else:
             zip_bytes, zip_name = export_full_session()
             if st.download_button(
-                label="⬇️ Descargar todo el etiquetado (ZIP)",
+                label=t("download_all_zip"),
                 data=zip_bytes,
                 file_name=zip_name,
                 mime="application/zip",
@@ -248,12 +267,12 @@ def render_downloader(image_id: str):
 
     # ── ML-ready formats (Idea F) ────────────────────────────────────────
     if summary["labeled"] > 0:
-        st.markdown("**Formatos para ML**")
+        st.markdown(t("ml_formats"))
         ml1, ml2 = st.columns(2)
         with ml1:
             csv_bytes, csv_name = export_huggingface_csv()
             if st.download_button(
-                label="📊 CSV (HuggingFace)",
+                label=t("hf_csv"),
                 data=csv_bytes,
                 file_name=csv_name,
                 mime="text/csv",
@@ -264,7 +283,7 @@ def render_downloader(image_id: str):
         with ml2:
             jsonl_bytes, jsonl_name = export_jsonl()
             if st.download_button(
-                label="📄 JSONL (Fine-tuning)",
+                label=t("jsonl_finetune"),
                 data=jsonl_bytes,
                 file_name=jsonl_name,
                 mime="application/jsonl",

interface/components/gallery.py

@@ -5,6 +5,7 @@ badges and click-to-select behaviour.
 """
 
 import streamlit as st
+from i18n import t
 from services import session_manager as sm
 
 
@@ -29,7 +30,7 @@ def render_gallery():
 
     # ── Progress bar ─────────────────────────────────────────────────────
     labeled, total = sm.get_labeling_progress()
-    progress_text = f"Progreso: **{labeled}** / **{total}** etiquetadas"
+    progress_text = f"{t('progress')}: **{labeled}** / **{total}** {t('labeled_suffix')}"
     st.markdown(progress_text)
     st.progress(labeled / total if total > 0 else 0)
 
@@ -88,18 +89,18 @@ def render_gallery():
         gc1, gc2, gc3 = st.columns([1, 3, 1])
         with gc1:
             if page > 0:
-                if st.button("◀ Ant.", key="gal_prev"):
+                if st.button(t("gallery_prev"), key="gal_prev"):
                     st.session_state.gallery_page -= 1
                     clicked = True
         with gc2:
             st.markdown(
                 f"<div style='text-align:center; padding-top:6px;'>"
-                f"Página {page + 1} / {total_pages}</div>",
+                f"{t('page')} {page + 1} / {total_pages}</div>",
                 unsafe_allow_html=True,
             )
         with gc3:
             if page < total_pages - 1:
-                if st.button("Sig. ▶", key="gal_next"):
+                if st.button(t("gallery_next"), key="gal_next"):
                     st.session_state.gallery_page += 1
                     clicked = True
 

interface/components/labeler.py

@@ -14,6 +14,7 @@ Numeric values are stored for ML; only text labels are shown in the UI.
 import streamlit as st
 import config
 import database as db
+from i18n import t, label_display, label_from_display, locs_display
 from services import session_manager as sm
 
 
@@ -36,7 +37,7 @@ def _render_locs_dropdown(field: dict, image_id: str, current_locs: dict) -> int
     """Render a single LOCS dropdown and return the selected numeric value."""
     field_id = field["field_id"]
     options = field["options"]
-    display_labels = [opt["display"] for opt in options]
+    display_labels = [locs_display(opt["display"]) for opt in options]
 
     # Determine current index from stored data
     stored_value = current_locs.get(field_id)
@@ -50,11 +51,11 @@ def _render_locs_dropdown(field: dict, image_id: str, current_locs: dict) -> int
 
     # Use index=None so nothing is pre-selected until doctor chooses
     selected_display = st.selectbox(
-        field["label"],
+        locs_display(field["label"]),
         display_labels,
         index=current_index,
         key=f"locs_{field_id}_{image_id}",
-        placeholder="Seleccionar…",
+        placeholder=t("locs_placeholder"),
     )
 
     if selected_display is not None and selected_display in display_labels:
@@ -69,31 +70,37 @@ def render_labeler(image_id: str):
     if img is None:
         return
 
-    st.subheader("🏷️ Etiquetado")
+    st.subheader(t("labeling"))
 
     # ── 1. Categorical classification ────────────────────────────────────
-    display_options = [opt["display"] for opt in config.LABEL_OPTIONS]
-    current_label = img.get("label")
-
-    if current_label is not None and current_label in display_options:
-        current_index = display_options.index(current_label)
+    # Translated display (UI only); storage always uses English name.
+    translated_options = [label_display(opt["display"]) for opt in config.LABEL_OPTIONS]
+    current_label = img.get("label")  # English, e.g. "Cataract"
+
+    if current_label is not None:
+        translated_current = label_display(current_label)
+        if translated_current in translated_options:
+            current_index = translated_options.index(translated_current)
+        else:
+            current_index = None
     else:
         current_index = None
 
     with st.container(border=True):
         if current_index is None:
-            st.caption("⬇️ Seleccione una etiqueta para esta imagen")
+            st.caption(t("select_label_hint"))
 
         selected = st.radio(
-            "Clasificación",
-            display_options,
+            t("classification"),
+            translated_options,
             index=current_index,
             key=f"label_radio_{image_id}",
             horizontal=True,
             label_visibility="collapsed",
         )
 
-    new_label = selected if selected in display_options else None
+    # Map translated selection back to English for storage
+    new_label = label_from_display(selected) if selected in translated_options else None
 
     # Detect categorical change
     label_changed = new_label is not None and new_label != current_label
@@ -110,7 +117,7 @@ def render_labeler(image_id: str):
     effective_label = new_label or current_label
     if effective_label == "Cataract":
         st.markdown("---")
-        st.markdown("**LOCS III Classification**")
+        st.markdown(t("locs_title"))
 
         current_locs = img.get("locs_data", {})
         locs_changed = False
@@ -133,12 +140,12 @@ def render_labeler(image_id: str):
         filled = sum(1 for f in config.LOCS_FIELDS if f["field_id"] in current_locs)
         total_fields = len(config.LOCS_FIELDS)
         if filled < total_fields:
-            st.info(f"📋 LOCS: {filled}/{total_fields} campos completados")
+            st.info(t("locs_progress", filled=filled, total=total_fields))
         else:
-            st.success(f"✅ LOCS: {filled}/{total_fields} campos completados")
+            st.success(t("locs_complete", filled=filled, total=total_fields))
 
-    # ── 3. Visual feedback ───────────────────────────────────────────────
+    # ── 3. Visual feedback ───────────────────────────────────────────────────
     if effective_label is None:
-        st.warning("🔴 Sin etiquetar")
+        st.warning(t("unlabeled"))
     else:
-        st.success(f"🟢 Etiqueta: **{effective_label}**")
+        st.success(f"{t('label_set')}: **{label_display(effective_label)}**")

interface/components/recorder.py

@@ -10,6 +10,7 @@ Includes timestamped segments from Whisper for reference.
 import hashlib
 import streamlit as st
 import database as db
+from i18n import t
 from services import session_manager as sm
 from services.whisper_service import transcribe_audio_with_timestamps, format_timestamp
 
@@ -35,25 +36,49 @@ def render_recorder(image_id: str, model, language: str):
     if img is None:
         return
 
-    st.subheader("🎙️ Dictado y Transcripción")
+    st.subheader(t("dictation"))
+
+    # Track which audio blob we already processed so we don't re-transcribe
+    processed_key = f"_last_audio_{image_id}"
+    segments_key = f"_segments_{image_id}"
+
+    # ── Handle button actions BEFORE widget rendering ────────────────────
+    # Streamlit forbids setting a widget's session_state key after the widget
+    # is instantiated. We use callback flags to detect button presses from
+    # the *previous* rerun and apply state changes *before* the text_area.
+    _rerecord_flag = f"_flag_rerecord_{image_id}"
+    _restore_flag = f"_flag_restore_{image_id}"
+
+    if st.session_state.pop(_rerecord_flag, False):
+        img["audio_bytes"] = None
+        img["transcription"] = ""
+        img["transcription_original"] = ""
+        st.session_state.pop(segments_key, None)
+        st.session_state.pop(processed_key, None)
+        st.session_state.pop(f"audio_input_{image_id}", None)
+        # Set value BEFORE the text_area is created
+        st.session_state[f"transcription_area_{image_id}"] = ""
+        sm.update_activity()
+
+    if st.session_state.pop(_restore_flag, False):
+        img["transcription"] = img["transcription_original"]
+        # Set value BEFORE the text_area is created
+        st.session_state[f"transcription_area_{image_id}"] = img["transcription_original"]
+        sm.update_activity()
 
     # ── Audio recording ──────────────────────────────────────────────────
     audio_wav = st.audio_input(
-        "Grabar audio",
+        t("record_audio"),
         key=f"audio_input_{image_id}",
     )
 
-    # Track which audio blob we already processed so we don't re-transcribe
-    processed_key = f"_last_audio_{image_id}"
-    segments_key = f"_segments_{image_id}"
-
     if audio_wav is not None:
         audio_bytes = audio_wav.getvalue()
         fingerprint = _audio_fingerprint(audio_bytes)
 
         # Only transcribe if this is a *new* recording (content changed)
         if st.session_state.get(processed_key) != fingerprint:
-            with st.spinner("Transcribiendo audio…"):
+            with st.spinner(t("transcribing")):
                 text, segments = transcribe_audio_with_timestamps(
                     model, audio_bytes, language
                 )
@@ -101,11 +126,11 @@ def render_recorder(image_id: str, model, language: str):
 
     # ── Editable transcription ───────────────────────────────────────────
     edited_text = st.text_area(
-        "Transcripción (editable)",
+        t("transcription_editable"),
         value=img["transcription"],
         height=180,
         key=f"transcription_area_{image_id}",
-        placeholder="Grabe un audio o escriba la transcripción manualmente…",
+        placeholder=t("transcription_placeholder"),
     )
 
     # Sync edits back to session
@@ -116,7 +141,7 @@ def render_recorder(image_id: str, model, language: str):
     # ── Timestamped segments (Idea C) ────────────────────────────────────
     segments = st.session_state.get(segments_key, [])
     if segments:
-        with st.expander("🕐 Segmentos con timestamps", expanded=False):
+        with st.expander(t("segments_timestamps"), expanded=False):
             for seg in segments:
                 ts_start = format_timestamp(seg["start"])
                 ts_end = format_timestamp(seg["end"])
@@ -125,54 +150,31 @@ def render_recorder(image_id: str, model, language: str):
                 )
 
     # ── Helper buttons ───────────────────────────────────────────────────
-    btn_cols = st.columns(3)
+    btn_cols = st.columns(2)
 
     with btn_cols[0]:
-        # Re-record: clear audio and transcription so a new recording can be made
+        # Re-record: set flag → rerun → flag handler above clears state
         has_audio = img["audio_bytes"] is not None
         if st.button(
-            "🎤 Volver a grabar",
+            t("re_record"),
             key=f"rerecord_{image_id}",
             disabled=not has_audio,
             use_container_width=True,
         ):
-            img["audio_bytes"] = None
-            img["transcription"] = ""
-            img["transcription_original"] = ""
-            st.session_state.pop(segments_key, None)
-            st.session_state.pop(processed_key, None)
-            # Clear both text_area and audio_input widget states
-            st.session_state[f"transcription_area_{image_id}"] = ""
-            st.session_state.pop(f"audio_input_{image_id}", None)
-            sm.update_activity()
+            st.session_state[_rerecord_flag] = True
             st.rerun()
 
     with btn_cols[1]:
-        # Restore original Whisper transcription
+        # Restore original: set flag → rerun → flag handler above restores
         has_original = bool(img["transcription_original"])
         is_different = img["transcription"] != img["transcription_original"]
         if st.button(
-            "🔄 Restaurar original",
+            t("restore_original"),
             key=f"restore_{image_id}",
             disabled=not (has_original and is_different),
             use_container_width=True,
         ):
-            img["transcription"] = img["transcription_original"]
-            st.session_state[f"transcription_area_{image_id}"] = img["transcription_original"]
-            sm.update_activity()
-            st.rerun()
-
-    with btn_cols[2]:
-        # Clear transcription entirely
-        if st.button(
-            "🗑️ Limpiar texto",
-            key=f"clear_text_{image_id}",
-            disabled=not img["transcription"],
-            use_container_width=True,
-        ):
-            img["transcription"] = ""
-            st.session_state[f"transcription_area_{image_id}"] = ""
-            sm.update_activity()
+            st.session_state[_restore_flag] = True
             st.rerun()
 
     # ── Status line ──────────────────────────────────────────────────────
@@ -182,8 +184,8 @@ def render_recorder(image_id: str, model, language: str):
             img["transcription_original"]
             and img["transcription"] != img["transcription_original"]
         ):
-            modified_tag = "  ✏️ _modificada manualmente_"
+            modified_tag = t("manually_modified")
         word_count = len(img["transcription"].split())
-        st.caption(f"{word_count} palabras{modified_tag}")
+        st.caption(f"{t('word_count', count=word_count)}{modified_tag}")
     else:
-        st.caption("Sin transcripción aún.")
+        st.caption(t("no_transcription_yet"))

interface/components/uploader.py

@@ -9,6 +9,7 @@ Uses @st.dialog modals to warn about:
 import streamlit as st
 import config
 import database as db
+from i18n import t
 from services import session_manager as sm
 from utils import validate_image_bytes
 
@@ -19,49 +20,48 @@ def _reset_uploader():
 
 
 # ── Modal: previously labeled images ─────────────────────────────────────────
-@st.dialog("⚠️ Imágenes ya etiquetadas", width="large", dismissible=False)
 def _show_relabel_dialog():
     """Modal dialog asking the doctor which previously-labeled images to re-upload."""
-    pending = st.session_state.get("_pending_upload_review")
-    if not pending:
-        st.rerun()
-        return
-
-    prev = pending["previously_labeled"]
-    non_labeled_count = len(pending["files"]) - len(prev)
 
-    st.markdown(
-        f"**{len(prev)} imagen(es)** ya fueron etiquetadas anteriormente. "
-        "Seleccione cuáles desea volver a etiquetar."
-    )
-    if non_labeled_count > 0:
-        st.info(
-            f"ℹ️ Las otras **{non_labeled_count}** imagen(es) nuevas se subirán automáticamente."
-        )
-
-    relabel_choices = {}
-    for fname, records in prev.items():
-        latest = records[0]
-        label_info = latest.get("label", "—")
-        doctor_info = latest.get("doctorName", "—")
-        ts_info = str(latest.get("createdAt", ""))[:16]
-        n_times = len(records)
-        badge = f"({n_times} vez{'es' if n_times > 1 else ''})"
-
-        relabel_choices[fname] = st.checkbox(
-            f"**{fname}** — _{label_info}_ | {doctor_info} | {ts_info} {badge}",
-            value=True,
-            key=f"_dlg_relabel_{fname}",
-        )
+    @st.dialog(t("dlg_relabel"), width="large", dismissible=False)
+    def _dlg():
+        pending = st.session_state.get("_pending_upload_review")
+        if not pending:
+            st.rerun()
+            return
 
-    st.divider()
-    col_a, col_b = st.columns(2)
-    with col_a:
-        if st.button("✅ Aceptar y subir", type="primary", use_container_width=True):
-            _process_pending(relabel_choices)
-    with col_b:
-        if st.button("❌ Cancelar etiquetadas", use_container_width=True):
-            _cancel_pending()
+        prev = pending["previously_labeled"]
+        non_labeled_count = len(pending["files"]) - len(prev)
+
+        st.markdown(t("relabel_dialog_msg", count=len(prev)))
+        if non_labeled_count > 0:
+            st.info(t("relabel_new_info", count=non_labeled_count))
+
+        relabel_choices = {}
+        for fname, records in prev.items():
+            latest = records[0]
+            label_info = latest.get("label", "—")
+            doctor_info = latest.get("doctorName", "—")
+            ts_info = str(latest.get("createdAt", ""))[:16]
+            n_times = len(records)
+            badge = t("times_badge_plural", n=n_times) if n_times > 1 else t("times_badge", n=n_times)
+
+            relabel_choices[fname] = st.checkbox(
+                f"**{fname}** — _{label_info}_ | {doctor_info} | {ts_info} ({badge})",
+                value=True,
+                key=f"_dlg_relabel_{fname}",
+            )
+
+        st.divider()
+        col_a, col_b = st.columns(2)
+        with col_a:
+            if st.button(t("accept_upload"), type="primary", use_container_width=True):
+                _process_pending(relabel_choices)
+        with col_b:
+            if st.button(t("cancel_labeled"), use_container_width=True):
+                _cancel_pending()
+
+    _dlg()
 
 
 def _process_pending(relabel_choices: dict[str, bool]):
@@ -128,24 +128,27 @@ def _cancel_pending():
 
 
 # ── Modal: session duplicates (informational) ────────────────────────────────
-@st.dialog("ℹ️ Imágenes duplicadas en sesión", dismissible=False)
 def _show_duplicates_dialog():
     """Informational modal listing images already present in the current session."""
-    dup_names = st.session_state.get("_session_duplicates", [])
-    if not dup_names:
-        st.rerun()
-        return
 
-    st.markdown(
-        "Las siguientes imágenes **ya se encuentran en la sesión actual** "
-        "y no se volverán a subir:"
-    )
-    for fname in dup_names:
-        st.markdown(f"- `{fname}`")
+    @st.dialog(t("dlg_duplicates"), dismissible=False)
+    def _dlg():
+        dup_names = st.session_state.get("_session_duplicates", [])
+        if not dup_names:
+            st.rerun()
+            return
 
-    if st.button("Aceptar", use_container_width=True):
-        st.session_state.pop("_session_duplicates", None)
-        st.rerun()
+        st.markdown(
+            t("duplicates_dialog_msg")
+        )
+        for fname in dup_names:
+            st.markdown(f"- `{fname}`")
+
+        if st.button(t("accept"), use_container_width=True):
+            st.session_state.pop("_session_duplicates", None)
+            st.rerun()
+
+    _dlg()
 
 
 # ── Main uploader ───────────────���────────────────────────────────────────────
@@ -157,11 +160,11 @@ def render_uploader():
     counter = st.session_state.get("_uploader_counter", 0)
 
     uploaded_files = st.file_uploader(
-        "📤 Subir imágenes médicas",
+        t("upload_images"),
         type=config.ALLOWED_EXTENSIONS,
         accept_multiple_files=True,
-        help=f"Formatos aceptados: {', '.join(config.ALLOWED_EXTENSIONS)}. "
-             f"Máx. {config.MAX_UPLOAD_SIZE_MB} MB por archivo.",
+        help=f"{t('upload_help_formats')}: {', '.join(config.ALLOWED_EXTENSIONS)}. "
+             f"{t('upload_help_max')} {config.MAX_UPLOAD_SIZE_MB} MB.",
         key=f"uploader_{counter}",
     )
 
@@ -241,7 +244,7 @@ def render_uploader():
 
     if skipped_invalid > 0:
         st.warning(
-            f"⚠️ {skipped_invalid} archivo(s) no son imágenes válidas y fueron ignorados."
+            f"⚠️ {skipped_invalid} {t('invalid_files')}"
         )
 
     if new_count > 0:

interface/config.py

@@ -86,5 +86,5 @@ APP_ICON = "👁️"
 APP_SUBTITLE = "Sistema de Etiquetado Médico Oftalmológico"
 
 # ── UI Language ──────────────────────────────────────────────────────────────
-# "es" = Español, "en" = English
-UI_LANGUAGE = "es"
+# Language is now managed via st.session_state["ui_language"] and i18n module.
+# Supported: "es" (Español), "en" (English).

interface/i18n.py

@@ -1,10 +1,19 @@
 """OphthalmoCapture — Internationalization (i18n)
 
-Centralized UI strings. Switch the active language by changing
-``ACTIVE_LANGUAGE``.  All components import strings from here.
+Centralized UI strings with session-state-based language selection.
+All components call t(key) to get translated strings.
 """
 
-ACTIVE_LANGUAGE = "es"
+import streamlit as st
+
+SUPPORTED_LANGUAGES = {"es": "Español", "en": "English"}
+DEFAULT_LANGUAGE = "es"
+
+
+def _get_lang() -> str:
+    """Return the active UI language code from session state."""
+    return st.session_state.get("ui_language", DEFAULT_LANGUAGE)
+
 
 _STRINGS = {
     "es": {
@@ -26,11 +35,11 @@ _STRINGS = {
         "label_header": "Etiqueta",
         "doctor_header": "Doctor",
         "no_transcription": "Sin transcripción",
-        "end_session": "🗑️ Finalizar Sesión",
+        "end_session": "� Cerrar sesión",
         "undownloaded_warning": "⚠️ Datos no descargados",
         "timeout_in": "⏱️ Timeout en",
-        "confirm_delete": "¿Está seguro? **Todos los datos se eliminarán permanentemente.**",
-        "yes_delete": "✅ Sí, eliminar",
+        "confirm_delete": "¿Está seguro? **Se cerrará la sesión y todos los datos se eliminarán permanentemente.**",
+        "yes_delete": "✅ Sí, cerrar sesión",
         "cancel": "❌ Cancelar",
         "logout": "🚪 Cerrar sesión",
         # Upload
@@ -94,6 +103,59 @@ _STRINGS = {
         # Auth
         "login_prompt": "👨‍⚕️ Inicie sesión para acceder al sistema de etiquetado.",
         "login_error": "❌ Usuario o contraseña incorrectos.",
+        # i18n
+        "ui_language": "🌐 Idioma / Language",
+        "loading_whisper": "Cargando modelo Whisper '{model}'...",
+        # Session expiry with placeholders
+        "session_expired": "⏰ Sesión expirada por inactividad ({minutes} min). Se eliminaron **{total}** imágenes, **{labeled}** etiquetadas, **{with_audio}** con audio. Descargue sus datos antes de que expire la sesión la próxima vez.",
+        "db_error": "Error crítico de base de datos: {error}",
+        "history_error": "Error al obtener historial: {error}",
+        # Labeler
+        "select_label_hint": "⬇️ Seleccione una etiqueta para esta imagen",
+        "locs_title": "**Clasificación LOCS III**",
+        "locs_placeholder": "Seleccionar…",
+        "locs_progress": "📋 LOCS: {filled}/{total} campos completados",
+        "locs_complete": "✅ LOCS: {filled}/{total} campos completados",
+        # Recorder
+        "re_record": "🎤 Volver a grabar",
+        "word_count": "{count} palabras",
+        # Downloader
+        "single_download": "📥 Descarga individual",
+        "session_info": "📊 Información de sesión",
+        "bulk_download": "📦 Descargar todo el etiquetado",
+        "download_all_zip": "⬇️ Descargar todo el etiquetado (ZIP)",
+        "download_file": "⬇️ Descargar — {filename}",
+        "incomplete_fields_msg": "La imagen **{filename}** tiene campos sin completar:",
+        "missing_categorical": "Etiqueta categórica",
+        "missing_locs": "LOCS III – {field}",
+        "missing_voice": "Etiquetado por voz",
+        "download_anyway": "⬇️ Descargar igualmente",
+        "go_back_finish": "🔙 Regresar y terminar",
+        "bulk_incomplete_msg": "**{count} imagen(es)** tienen etiquetado incompleto:",
+        "col_image": "Imagen",
+        "col_categorical": "Categórica",
+        "col_locs": "LOCS III",
+        "col_voice": "Voz",
+        "locs_not_required": "No Necesario",
+        "image_counter": "{current} de {total}",
+        # Gallery
+        "gallery_prev": "◀ Ant.",
+        "gallery_next": "Sig. ▶",
+        # Uploader
+        "relabel_dialog_msg": "**{count} imagen(es)** ya fueron etiquetadas anteriormente. Seleccione cuáles desea volver a etiquetar.",
+        "relabel_new_info": "ℹ️ Las otras **{count}** imagen(es) nuevas se subirán automáticamente.",
+        "accept_upload": "✅ Aceptar y subir",
+        "cancel_labeled": "❌ Cancelar etiquetadas",
+        "duplicates_dialog_msg": "Las siguientes imágenes **ya se encuentran en la sesión actual** y no se volverán a subir:",
+        "accept": "Aceptar",
+        # Dialog titles
+        "dlg_single_incomplete": "⚠️ Etiquetado incompleto",
+        "dlg_bulk_incomplete": "⚠️ Imágenes con etiquetado incompleto",
+        "dlg_relabel": "⚠️ Imágenes ya etiquetadas",
+        "dlg_duplicates": "ℹ️ Imágenes duplicadas en sesión",
+        # Uploader badge
+        "times_badge": "{n} vez",
+        "times_badge_plural": "{n} veces",
     },
     "en": {
         "app_subtitle": "Ophthalmological Medical Labeling System",
@@ -112,11 +174,11 @@ _STRINGS = {
         "label_header": "Label",
         "doctor_header": "Doctor",
         "no_transcription": "No transcription",
-        "end_session": "🗑️ End Session",
+        "end_session": "� Log out",
         "undownloaded_warning": "⚠️ Undownloaded data",
         "timeout_in": "⏱️ Timeout in",
-        "confirm_delete": "Are you sure? **All data will be permanently deleted.**",
-        "yes_delete": "✅ Yes, delete",
+        "confirm_delete": "Are you sure? **The session will be closed and all data permanently deleted.**",
+        "yes_delete": "✅ Yes, log out",
         "cancel": "❌ Cancel",
         "logout": "🚪 Log out",
         "upload_images": "📤 Upload medical images",
@@ -172,11 +234,134 @@ _STRINGS = {
         "download_before_expire": "Download your data before the session expires next time.",
         "login_prompt": "👨‍⚕️ Log in to access the labeling system.",
         "login_error": "❌ Wrong username or password.",
+        "ui_language": "🌐 Language / Idioma",
+        "loading_whisper": "Loading Whisper model '{model}'...",
+        "session_expired": "⏰ Session expired due to inactivity ({minutes} min). Removed **{total}** images, **{labeled}** labeled, **{with_audio}** with audio. Download your data before the session expires next time.",
+        "db_error": "Critical database error: {error}",
+        "history_error": "Error fetching history: {error}",
+        "select_label_hint": "⬇️ Select a label for this image",
+        "locs_title": "**LOCS III Classification**",
+        "locs_placeholder": "Select…",
+        "locs_progress": "📋 LOCS: {filled}/{total} fields completed",
+        "locs_complete": "✅ LOCS: {filled}/{total} fields completed",
+        "re_record": "🎤 Re-record",
+        "word_count": "{count} words",
+        "single_download": "📥 Individual Download",
+        "session_info": "📊 Session Information",
+        "bulk_download": "📦 Download All Labeling",
+        "download_all_zip": "⬇️ Download all labeling (ZIP)",
+        "download_file": "⬇️ Download — {filename}",
+        "incomplete_fields_msg": "Image **{filename}** has incomplete fields:",
+        "missing_categorical": "Categorical label",
+        "missing_locs": "LOCS III – {field}",
+        "missing_voice": "Voice labeling",
+        "download_anyway": "⬇️ Download anyway",
+        "go_back_finish": "🔙 Go back and finish",
+        "bulk_incomplete_msg": "**{count} image(s)** have incomplete labeling:",
+        "col_image": "Image",
+        "col_categorical": "Categorical",
+        "col_locs": "LOCS III",
+        "col_voice": "Voice",
+        "locs_not_required": "Not Required",
+        "image_counter": "{current} of {total}",
+        "gallery_prev": "◀ Prev",
+        "gallery_next": "Next ▶",
+        "relabel_dialog_msg": "**{count} image(s)** were previously labeled. Select which ones to re-label.",
+        "relabel_new_info": "ℹ️ The other **{count}** new image(s) will be uploaded automatically.",
+        "accept_upload": "✅ Accept and upload",
+        "cancel_labeled": "❌ Cancel labeled",
+        "duplicates_dialog_msg": "The following images **are already in the current session** and will not be re-uploaded:",
+        "accept": "Accept",
+        "dlg_single_incomplete": "⚠️ Incomplete labeling",
+        "dlg_bulk_incomplete": "⚠️ Images with incomplete labeling",
+        "dlg_relabel": "⚠️ Previously labeled images",
+        "dlg_duplicates": "ℹ️ Duplicate images in session",
+        "times_badge": "{n} time",
+        "times_badge_plural": "{n} times",
+    },
+}
+
+
+def t(key: str, **kwargs) -> str:
+    """Return the translated string for *key*, with optional format kwargs."""
+    lang = _get_lang()
+    text = _STRINGS.get(lang, _STRINGS["es"]).get(key, key)
+    if kwargs:
+        try:
+            text = text.format(**kwargs)
+        except (KeyError, IndexError):
+            pass
+    return text
+
+
+# ── Label display translations ───────────────────────────────────────────────
+# Labels are stored in English (config.LABEL_OPTIONS["display"]).
+# These mappings translate for UI display only.
+
+_LABEL_DISPLAY = {
+    "es": {
+        "Normal": "Normal",
+        "Cataract": "Catarata",
+        "Bad quality": "Mala calidad",
+        "Needs dilation": "Necesita dilatación",
+    },
+    "en": {
+        "Normal": "Normal",
+        "Cataract": "Cataract",
+        "Bad quality": "Bad quality",
+        "Needs dilation": "Needs dilation",
+    },
+}
+
+
+def label_display(english_name: str) -> str:
+    """Translate a label's English display name to the active UI language."""
+    lang = _get_lang()
+    return _LABEL_DISPLAY.get(lang, _LABEL_DISPLAY["en"]).get(english_name, english_name)
+
+
+def label_from_display(translated_name: str) -> str | None:
+    """Reverse-map a translated label back to its English storage name."""
+    lang = _get_lang()
+    mapping = _LABEL_DISPLAY.get(lang, _LABEL_DISPLAY["en"])
+    reverse = {v: k for k, v in mapping.items()}
+    return reverse.get(translated_name)
+
+
+# ── LOCS display translations ─────────────────────────────────────────���──────
+
+_LOCS_DISPLAY = {
+    "es": {
+        "Nuclear Cataract \u2013 Opalescence (NO)": "Catarata Nuclear \u2013 Opalescencia (NO)",
+        "Nuclear Cataract \u2013 Color (NC)": "Catarata Nuclear \u2013 Color (NC)",
+        "Cortical Cataract (C)": "Catarata Cortical (C)",
+        "None / Clear": "Ninguna / Transparente",
+        "Very mild": "Muy leve",
+        "Mild": "Leve",
+        "Mild\u2013moderate": "Leve\u2013moderada",
+        "Moderate": "Moderada",
+        "Moderate\u2013severe": "Moderada\u2013severa",
+        "Severe": "Severa",
+        "Very mild yellowing": "Amarillamiento muy leve",
+        "Mild yellowing": "Amarillamiento leve",
+        "Moderate yellow": "Amarillo moderado",
+        "Yellow\u2013brown": "Amarillo\u2013marrón",
+        "Brown": "Marrón",
+        "Dark brown": "Marrón oscuro",
+        "None": "Ninguna",
+        "Peripheral spokes only": "Solo radios periféricos",
+        "Mild peripheral involvement": "Compromiso periférico leve",
+        "Moderate spokes approaching center": "Radios moderados acercándose al centro",
+        "Central involvement": "Compromiso central",
+        "Severe / dense central spokes": "Severa / radios centrales densos",
     },
+    "en": {},
 }
 
 
-def t(key: str) -> str:
-    """Return the translated string for *key* in the active language."""
-    lang_dict = _STRINGS.get(ACTIVE_LANGUAGE, _STRINGS["es"])
-    return lang_dict.get(key, key)
+def locs_display(english_text: str) -> str:
+    """Translate a LOCS field label or option to the active UI language."""
+    lang = _get_lang()
+    if lang == "en":
+        return english_text
+    return _LOCS_DISPLAY.get(lang, {}).get(english_text, english_text)

interface/main.py

@@ -7,7 +7,7 @@ import math
 import config
 import database as db
 import utils
-import i18n
+from i18n import t, label_display, SUPPORTED_LANGUAGES, DEFAULT_LANGUAGE
 from services import session_manager as sm
 from services.whisper_service import load_whisper_model
 from components.uploader import render_uploader
@@ -16,7 +16,7 @@ from components.labeler import render_labeler
 from components.recorder import render_recorder
 from components.downloader import render_downloader
 from components.image_protection import inject_image_protection
-from services.auth_service import require_auth, render_logout_button
+from services.auth_service import require_auth, do_logout
 
 # ── PAGE CONFIG ──────────────────────────────────────────────────────────────
 st.set_page_config(
@@ -31,8 +31,10 @@ if not require_auth():
 # ── IMAGE PROTECTION (prevent download / right-click save) ───────────────────
 inject_image_protection()
 
-# Set UI language from config
-i18n.ACTIVE_LANGUAGE = config.UI_LANGUAGE
+# ── UI LANGUAGE (initialize before anything renders) ─────────────────────────
+if "ui_language" not in st.session_state:
+    st.session_state.ui_language = DEFAULT_LANGUAGE
+
 # ── SESSION INITIALIZATION ──────────────────────────────────────────────────
 sm.init_session()
 
@@ -40,15 +42,13 @@ sm.init_session()
 if sm.check_session_timeout(config.SESSION_TIMEOUT_MINUTES):
     if sm.has_undownloaded_data():
         summary = sm.get_session_data_summary()
-        st.warning(
-            f"⏰ Sesión expirada por inactividad ({config.SESSION_TIMEOUT_MINUTES} min). "
-            f"Se eliminaron **{summary['total']}** imágenes, "
-            f"**{summary['labeled']}** etiquetadas, "
-            f"**{summary['with_audio']}** con audio. "
-            "Descargue sus datos antes de que expire la sesión la próxima vez."
-        )
+        st.warning(t("session_expired",
+                     minutes=config.SESSION_TIMEOUT_MINUTES,
+                     total=summary['total'],
+                     labeled=summary['labeled'],
+                     with_audio=summary['with_audio']))
     else:
-        st.info("⏰ Sesión expirada por inactividad. Se inició una nueva sesión.")
+        st.info(t("session_expired_clean"))
     sm.clear_session()
     sm.init_session()
 
@@ -57,19 +57,33 @@ utils.setup_env()
 try:
     active_db_type = db.init_db()
 except Exception as e:
-    st.error(f"Error crítico de base de datos: {e}")
+    st.error(t("db_error", error=str(e)))
     st.stop()
 
 # ── SIDEBAR ──────────────────────────────────────────────────────────────────
 with st.sidebar:
-    st.title("⚙️ Configuración")
+    st.title(t("settings"))
+
+    # Language selector
+    lang_codes = list(SUPPORTED_LANGUAGES.keys())
+    lang_names = list(SUPPORTED_LANGUAGES.values())
+    current_lang_idx = lang_codes.index(st.session_state.ui_language) if st.session_state.ui_language in lang_codes else 0
+    selected_ui_lang = st.selectbox(
+        t("ui_language"),
+        lang_names,
+        index=current_lang_idx,
+        key="_ui_language_selector",
+    )
+    new_lang_code = lang_codes[lang_names.index(selected_ui_lang)]
+    if new_lang_code != st.session_state.ui_language:
+        st.session_state.ui_language = new_lang_code
+        st.rerun()
 
-    # Logout button (only visible if auth is active)
-    render_logout_button()
+    st.divider()
 
     # Doctor name
     doctor = st.text_input(
-        "👨‍⚕️ Nombre del Doctor",
+        t("doctor_name"),
         value=st.session_state.get("doctor_name", ""),
     )
     if doctor != st.session_state.get("doctor_name", ""):
@@ -80,7 +94,7 @@ with st.sidebar:
     # Whisper language (select FIRST so models can be filtered)
     lang_keys = list(config.WHISPER_LANGUAGE_OPTIONS.keys())
     lang_labels = list(config.WHISPER_LANGUAGE_OPTIONS.values())
-    selected_lang_display = st.selectbox("Idioma de dictado", lang_labels, index=0)
+    selected_lang_display = st.selectbox(t("dictation_language"), lang_labels, index=0)
     selected_language = lang_keys[lang_labels.index(selected_lang_display)]
 
     # Whisper model — filtered by selected language
@@ -96,7 +110,7 @@ with st.sidebar:
             m for m in config.WHISPER_MODEL_OPTIONS if not m.endswith(".en")
         ]
     selected_model = st.selectbox(
-        "Modelo Whisper",
+        t("whisper_model"),
         available_models,
         index=0,
     )
@@ -105,21 +119,21 @@ with st.sidebar:
 
     # ── Session progress ──────────────────────────────────────────���──────────
     labeled, total = sm.get_labeling_progress()
-    st.subheader("📊 Sesión Actual")
-    st.caption(f"Base de datos: **{active_db_type}**")
+    st.subheader(t("current_session"))
+    st.caption(f"{t('db_type')}: **{active_db_type}**")
     if total > 0:
-        st.write(f"Imágenes cargadas: **{total}**")
-        st.write(f"Etiquetadas: **{labeled}** / {total}")
+        st.write(f"{t('images_loaded')}: **{total}**")
+        st.write(f"{t('labeled_count')}: **{labeled}** / {total}")
         st.progress(labeled / total if total > 0 else 0)
     else:
-        st.info("No hay imágenes en la sesión.")
+        st.info(t("no_images"))
 
     st.divider()
 
     # ── Annotation History (from DB) — Grouped by image ────────────────────────
-    st.subheader("🗄️ Historial")
+    st.subheader(t("history"))
     search_input = st.text_input(
-        "🔍 Buscar por imagen",
+        t("search_image"),
         value=st.session_state.get("history_search", ""),
     )
     if search_input != st.session_state.get("history_search", ""):
@@ -138,11 +152,11 @@ with st.sidebar:
             ITEMS_PER_PAGE,
         )
     except Exception as e:
-        st.error(f"Error al obtener historial: {e}")
+        st.error(t("history_error", error=str(e)))
         history_groups, total_items = [], 0
 
     if not history_groups:
-        st.caption("Sin registros.")
+        st.caption(t("no_records"))
     else:
         for group in history_groups:
             fname = group["imageFilename"]
@@ -166,12 +180,12 @@ with st.sidebar:
                         st.markdown(
                             f"**#{i + 1}** — `{ts}`"
                         )
-                    st.write(f"**Etiqueta:** {label}")
-                    st.write(f"**Doctor:** {doctor}")
+                    st.write(f"**{t('label_header')}:** {label_display(label) if label != '—' else label}")
+                    st.write(f"**{t('doctor_header')}:** {doctor}")
                     if preview:
                         st.caption(f"📝 {preview}")
                     else:
-                        st.caption("_Sin transcripción_")
+                        st.caption(f"_{t('no_transcription')}_")
 
                     if i < n_annotations - 1:
                         st.divider()
@@ -203,37 +217,36 @@ with st.sidebar:
         summary = sm.get_session_data_summary()
         remaining = sm.get_remaining_timeout_minutes(config.SESSION_TIMEOUT_MINUTES)
         st.warning(
-            f"⚠️ Datos no descargados: **{summary['total']}** imágenes, "
-            f"**{summary['labeled']}** etiquetadas, "
-            f"**{summary['with_audio']}** con audio."
+            f"{t('undownloaded_warning')}: **{summary['total']}** {t('images_metric')}, "
+            f"**{summary['labeled']}** {t('labeled_count')}, "
+            f"**{summary['with_audio']}** {t('with_audio')}."
         )
-        st.caption(f"⏱️ Timeout en ~{remaining:.0f} min")
+        st.caption(f"{t('timeout_in')} ~{remaining:.0f} min")
 
     # Two-step confirmation to prevent accidental data loss
     if not st.session_state.get("confirm_end_session", False):
         if st.button(
-            "🗑️ Finalizar Sesión",
+            t("logout"),
             type="secondary",
             use_container_width=True,
         ):
             st.session_state.confirm_end_session = True
             st.rerun()
     else:
-        st.error(
-            "¿Está seguro? **Todos los datos se eliminarán permanentemente.**"
-        )
+        st.error(t("confirm_delete"))
         cc1, cc2 = st.columns(2)
         with cc1:
-            if st.button("✅ Sí, eliminar", type="primary", use_container_width=True):
+            if st.button(t("yes_delete"), type="primary", use_container_width=True):
                 sm.clear_session()
+                do_logout()
                 st.rerun()
         with cc2:
-            if st.button("❌ Cancelar", use_container_width=True):
+            if st.button(t("cancel"), use_container_width=True):
                 st.session_state.confirm_end_session = False
                 st.rerun()
 
 # ── LOAD WHISPER MODEL ───────────────────────────────────────────────────────
-with st.spinner(f"Cargando modelo Whisper '{selected_model}'..."):
+with st.spinner(t("loading_whisper", model=selected_model)):
     model = load_whisper_model(selected_model)
 # ── BROWSER CLOSE GUARD (beforeunload) ───────────────────────────────────
 # Warn the user when they try to close/reload the tab with data in session.
@@ -251,7 +264,7 @@ if sm.has_undownloaded_data() and not st.session_state.get("session_downloaded",
     )
 # ── MAIN CONTENT ─────────────────────────────────────────────────────────────
 st.title(f"{config.APP_ICON} {config.APP_TITLE}")
-st.caption(config.APP_SUBTITLE)
+st.caption(t("app_subtitle"))
 
 # ── IMAGE UPLOAD ─────────────────────────────────────────────────────────────
 new_count = render_uploader()
@@ -260,7 +273,7 @@ if new_count > 0:
 
 # ── WORKSPACE (requires at least one image) ──────────────────────────────────
 if not st.session_state.image_order:
-    st.info("📤 Suba imágenes médicas para comenzar el etiquetado.")
+    st.info(t("upload_prompt"))
     st.stop()
 
 # ── IMAGE GALLERY ────────────────────────────────────────────────────────────
@@ -296,7 +309,7 @@ st.image(
 
 c1, c2, c3 = st.columns([1, 2, 1])
 with c1:
-    if st.button("⬅️ Anterior", disabled=(len(order) <= 1)):
+    if st.button(t("previous"), disabled=(len(order) <= 1)):
         new_idx = (current_idx - 1) % len(order)
         st.session_state.current_image_id = order[new_idx]
         sm.update_activity()
@@ -304,17 +317,17 @@ with c1:
 with c2:
     st.markdown(
         f"<div style='text-align:center'><b>{current_img['filename']}</b>"
-        f"<br>({current_idx + 1} de {len(order)})</div>",
+        f"<br>({t('image_counter', current=current_idx + 1, total=len(order))})</div>",
         unsafe_allow_html=True,
     )
 with c3:
-    if st.button("Siguiente ➡️", disabled=(len(order) <= 1)):
+    if st.button(t("next"), disabled=(len(order) <= 1)):
         new_idx = (current_idx + 1) % len(order)
         st.session_state.current_image_id = order[new_idx]
         sm.update_activity()
         st.rerun()
 
-if st.button("🗑️ Eliminar esta imagen", key="delete_img"):
+if st.button(t("delete_image"), key="delete_img"):
     sm.remove_image(current_id)
     sm.update_activity()
     st.rerun()

interface/services/auth_service.py

@@ -16,6 +16,8 @@ try:
 except ImportError:
     AUTH_AVAILABLE = False
 
+from i18n import t
+
 
 # ── Default credentials ──────────────────────────────────────────────────────
 # In production, load these from a secure YAML/env.  For now, hardcoded demo.
@@ -81,11 +83,11 @@ def require_auth() -> bool:
         return True
 
     elif st.session_state.get("authentication_status") is False:
-        st.error("❌ Usuario o contraseña incorrectos.")
+        st.error(t("login_error"))
         return False
 
     else:
-        st.info("👨‍⚕️ Inicie sesión para acceder al sistema de etiquetado.")
+        st.info(t("login_prompt"))
         return False
 
 
@@ -96,4 +98,18 @@ def render_logout_button():
 
     if st.session_state.get("authentication_status"):
         authenticator = _get_authenticator()
-        authenticator.logout("🚪 Cerrar sesión", location="sidebar")
+        authenticator.logout(t("logout"), location="sidebar")
+
+
+def do_logout():
+    """Programmatically log out the current user."""
+    if not AUTH_AVAILABLE:
+        return
+    try:
+        authenticator = _get_authenticator()
+        authenticator.logout(location="unrendered")
+    except Exception:
+        # Fallback: clear auth keys manually
+        for key in ("authentication_status", "username", "name", "logout"):
+            st.session_state.pop(key, None)
+        st.session_state.pop("authenticator", None)