Implementacion de funcionalidades varias, entre ellas la limitacion de descarga de imagenes desde la herramienta, descarga de etiquetado en diferentes formatos, etc

.gitattributes

@@ -0,0 +1,6 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -48,7 +48,6 @@ lightning_logs/
 .streamlit/secrets.toml
 .streamlit/.cache
 .streamlit/cache
-.streamlit/config.toml
 
 # =====================
 # Logs & Temp Files

.streamlit/config.toml

@@ -2,6 +2,8 @@
 headless = true
 port = 8501
 enableCORS = false
+maxUploadSize = 50
+enableXsrfProtection = true
 
 [browser]
 gatherUsageStats = false

README.md

@@ -1,59 +1,159 @@
-# How to Run MedGemma
+# 👁️ OphthalmoCapture
 
-This guide explains how to set up the environment and run both the Streamlit interface and the Jupyter Notebook for the MedGemma project.
+**Sistema de Etiquetado Médico Oftalmológico** — Interfaz web para cargar imágenes de fondo de ojo, etiquetarlas (catarata / no catarata), dictar observaciones por voz con transcripción automática (Whisper) y descargar el paquete de etiquetado completo.
 
-## 1. Prerequisites & Setup
+> **Modelo de sesión efímera:** las imágenes y el audio viven únicamente en la memoria del navegador/servidor durante la sesión. Nunca se persisten en disco ni en base de datos. Solo se almacenan metadatos de auditoría (etiqueta, transcripción, médico, fecha).
 
-### A. Download the Dataset
+---
 
-The application requires the fundus image dataset to function.
+## 1. Requisitos previos
 
-1. **Download:** [**Click here to download full-fundus.zip**](https://upm365-my.sharepoint.com/:u:/g/personal/angelmario_garcia_upm_es/IQCP3cLo1x3tRK_TFCrt2HR0AfSAca5rzHrwaRa4Cm-EfL4?e=UcrIgy)
-2. **Extract:** Unzip the file into the root directory of your project.
-   * **Verify:** Ensure you see a folder named `full-fundus/` in your project folder.
+| Requisito | Versión mínima | Notas |
+|-----------|---------------|-------|
+| **Python** | 3.10+ | Recomendado 3.11 |
+| **pip** | 23+ | — |
+| **FFmpeg** | cualquier versión reciente | Necesario para OpenAI Whisper. [Instrucciones de instalación](https://ffmpeg.org/download.html) |
+| **GPU (opcional)** | CUDA 11.8+ | Acelera la transcripción con Whisper. Funciona sin GPU usando CPU. |
 
-### B. Install Dependencies
+---
 
-Make sure you have Python installed, then run:
+## 2. Instalación
+
+### A. Clonar el repositorio
+
+```bash
+git clone <URL_DEL_REPO>
+cd Automatic-Labeling-with-Medgemma
+```
+
+### B. Crear un entorno virtual (recomendado)
 
 ```bash
-pip install streamlit notebook torch transformers pillow whisper numba
-````
+python -m venv .venv
 
------
+# Windows
+.venv\Scripts\activate
 
-## 2. Running the Web Interface (Streamlit)
+# Linux / macOS
+source .venv/bin/activate
+```
 
-Use this method for a user-friendly dashboard to analyze images.
+### C. Instalar dependencias
 
-1. Open your terminal (Command Prompt or Terminal).
-2. Navigate to your project folder:
+```bash
+pip install -r requirements.txt
+```
 
-    ```bash
-    cd /path/to/your/project
-    ```
+Esto instala: `streamlit`, `openai-whisper`, `torch`, `pandas`, `pillow`, `streamlit-authenticator` y demás dependencias.
 
-3. Run the Streamlit application:
+> **Nota sobre PyTorch:** si tienes GPU NVIDIA y quieres usarla para Whisper, instala la versión con CUDA antes de instalar los requisitos:
+> ```bash
+> pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+> pip install -r requirements.txt
+> ```
 
-    ```bash
-    streamlit run interface/main.py
-    ```
+### D. Verificar FFmpeg
 
-4. A new tab will open in your browser automatically at `http://localhost:8501`.
+```bash
+ffmpeg -version
+```
 
------
+Si no está instalado:
+- **Windows:** `winget install ffmpeg` o descargar desde [ffmpeg.org](https://ffmpeg.org/download.html)
+- **macOS:** `brew install ffmpeg`
+- **Linux:** `sudo apt install ffmpeg`
 
-## 3\. Running the Notebook (Jupyter)
+---
+
+## 3. Ejecutar la interfaz web (Streamlit)
+
+```bash
+streamlit run interface/main.py
+```
+
+Se abrirá automáticamente en el navegador en **http://localhost:8501**.
+
+### Flujo de uso
+
+1. **Autenticación** — Si `streamlit-authenticator` está instalado, inicia sesión con las credenciales configuradas. Si no, entra en modo anónimo automáticamente.
+2. **Cargar imágenes** — Arrastra o selecciona imágenes de fondo de ojo (JPG, PNG, TIFF, máx. 50 MB cada una).
+3. **Galería** — Se muestra una tira de miniaturas con indicadores 🔴 (pendiente) / 🟢 (etiquetada). Haz clic para seleccionar.
+4. **Etiquetar** — Clasifica la imagen como *Catarata* o *No Catarata*.
+5. **Dictar observaciones** — Graba audio con el micrófono. Whisper transcribe automáticamente con timestamps. Puedes editar el texto resultante.
+6. **Descargar** — Descarga un ZIP individual (imagen + metadatos + audio + transcripción) o un paquete de la sesión completa. También disponible en formatos ML (HuggingFace CSV, JSONL).
+7. **Finalizar sesión** — El botón del sidebar limpia toda la memoria. También hay timeout automático de 30 min de inactividad.
+
+### Configuración
+
+Los parámetros se encuentran en `interface/config.py`:
+
+| Parámetro | Valor por defecto | Descripción |
+|-----------|-------------------|-------------|
+| `SESSION_TIMEOUT_MINUTES` | 30 | Minutos de inactividad antes de limpiar la sesión |
+| `MAX_UPLOAD_SIZE_MB` | 50 | Tamaño máximo por imagen |
+| `ALLOWED_EXTENSIONS` | jpg, jpeg, png, tif | Formatos de imagen aceptados |
+| `WHISPER_MODEL_OPTIONS` | tiny → turbo | Modelos de Whisper disponibles |
+| `DEFAULT_WHISPER_LANGUAGE` | es | Idioma por defecto para transcripción |
+| `UI_LANGUAGE` | es | Idioma de la interfaz (es / en) |
+| `LABEL_OPTIONS` | Catarata, No Catarata | Categorías de etiquetado |
+
+### Credenciales por defecto (modo autenticación)
+
+| Usuario | Contraseña | Rol |
+|---------|------------|-----|
+| admin | admin123 | Administrador |
+| doctor1 | admin123 | Médico |
+| doctor2 | admin123 | Médico |
+
+> ⚠️ Cambia estas credenciales en `interface/services/auth_service.py` antes de cualquier uso en producción.
+
+---
+
+## 4. Estructura del proyecto
+
+```
+interface/
+├── main.py                  # Orquestador principal de Streamlit
+├── config.py                # Constantes de configuración
+├── database.py              # Persistencia de metadatos (SQLite)
+├── utils.py                 # Utilidades generales (validación de imágenes)
+├── i18n.py                  # Internacionalización (es/en)
+├── components/
+│   ├── uploader.py          # Carga de imágenes con validación
+│   ├── gallery.py           # Galería de miniaturas con estado
+│   ├── labeler.py           # Clasificación (catarata / no catarata)
+│   ├── recorder.py          # Grabación de audio + transcripción Whisper
+│   └── downloader.py        # Descarga individual, masiva y formatos ML
+├── services/
+│   ├── session_manager.py   # Gestión de sesión efímera en memoria
+│   ├── whisper_service.py   # Carga y transcripción con Whisper
+│   ├── export_service.py    # Generación de ZIP, CSV, JSONL
+│   └── auth_service.py      # Autenticación (opcional)
+└── .streamlit/
+    └── config.toml          # Configuración de Streamlit
+```
+
+---
+
+## 5. Ejecutar el Notebook (Jupyter)
+
+Para explorar el modelo MedGemma, afinar parámetros o depurar:
+
+```bash
+jupyter notebook medgemma.ipynb
+```
 
-Use this method to see the code logic, fine-tune the model, or debug.
+Ejecuta las celdas secuencialmente con **Shift + Enter**.
 
-1. Open your terminal and navigate to the project folder.
-2. Launch Jupyter:
+---
 
-    ```bash
-    jupyter notebook medgemma.ipynb
-    ```
+## 6. Solución de problemas
 
-3. The Jupyter interface will open in your browser.
-4. Click on `medgemma.ipynb`.
-5. Run the cells sequentially (Shift + Enter) to execute the model.
+| Problema | Solución |
+|----------|----------|
+| `ModuleNotFoundError: No module named 'whisper'` | `pip install openai-whisper` |
+| `FileNotFoundError: ffmpeg not found` | Instala FFmpeg (ver sección 2.D) |
+| Audio no se graba en el navegador | Asegúrate de acceder por `localhost` o HTTPS. Los navegadores bloquean el micrófono en HTTP no local. |
+| `streamlit-authenticator` no disponible | La app funciona en modo anónimo automáticamente. Instalar con `pip install streamlit-authenticator` si se desea autenticación. |
+| Timeout de sesión inesperado | Ajusta `SESSION_TIMEOUT_MINUTES` en `config.py` |
+| Imágenes no se cargan | Verifica que el formato sea JPG/PNG/TIFF y que no supere 50 MB |

interface/components/downloader.py

@@ -0,0 +1,102 @@
+"""OphthalmoCapture — Download Component
+
+Provides individual and bulk download buttons for the labeling package.
+"""
+
+import streamlit as st
+from services.export_service import (
+    export_single_image,
+    export_full_session,
+    get_session_summary,
+    export_huggingface_csv,
+    export_jsonl,
+)
+
+
+def render_downloader(image_id: str):
+    """Render the download panel for the current image + bulk download."""
+    img = st.session_state.images.get(image_id)
+    if img is None:
+        return
+
+    st.subheader("📥 Descarga")
+
+    # ── Individual download ──────────────────────────────────────────────
+    st.markdown("**Imagen actual**")
+
+    can_download = img["label"] is not None
+    if not can_download:
+        st.info("Etiquete la imagen para habilitar la descarga individual.")
+    else:
+        zip_bytes, zip_name = export_single_image(image_id)
+        st.download_button(
+            label=f"⬇️ Descargar etiquetado — {img['filename']}",
+            data=zip_bytes,
+            file_name=zip_name,
+            mime="application/zip",
+            key=f"dl_single_{image_id}",
+            use_container_width=True,
+        )
+
+    st.divider()
+
+    # ── Bulk download ────────────────────────────────────────────────────
+    st.markdown("**Toda la sesión**")
+
+    summary = get_session_summary()
+    sc1, sc2 = st.columns(2)
+    with sc1:
+        st.metric("Imágenes", summary["total"])
+        st.metric("Con audio", summary["with_audio"])
+    with sc2:
+        st.metric("Etiquetadas", f"{summary['labeled']} / {summary['total']}")
+        st.metric("Con transcripción", summary["with_transcription"])
+
+    if summary["unlabeled"] > 0:
+        st.warning(
+            f"⚠️ {summary['unlabeled']} imagen(es) sin etiquetar. "
+            "Se incluirán en la descarga pero sin etiqueta."
+        )
+
+    if summary["total"] == 0:
+        st.info("No hay imágenes para descargar.")
+    else:
+        zip_bytes, zip_name = export_full_session()
+        if st.download_button(
+            label="⬇️ Descargar todo el etiquetado (ZIP)",
+            data=zip_bytes,
+            file_name=zip_name,
+            mime="application/zip",
+            key="dl_bulk",
+            use_container_width=True,
+            type="primary",
+        ):
+            st.session_state.session_downloaded = True
+
+    # ── ML-ready formats (Idea F) ────────────────────────────────────────
+    if summary["labeled"] > 0:
+        st.divider()
+        st.markdown("**Formatos para ML**")
+        ml1, ml2 = st.columns(2)
+        with ml1:
+            csv_bytes, csv_name = export_huggingface_csv()
+            if st.download_button(
+                label="📊 CSV (HuggingFace)",
+                data=csv_bytes,
+                file_name=csv_name,
+                mime="text/csv",
+                key="dl_hf_csv",
+                use_container_width=True,
+            ):
+                st.session_state.session_downloaded = True
+        with ml2:
+            jsonl_bytes, jsonl_name = export_jsonl()
+            if st.download_button(
+                label="📄 JSONL (Fine-tuning)",
+                data=jsonl_bytes,
+                file_name=jsonl_name,
+                mime="application/jsonl",
+                key="dl_jsonl",
+                use_container_width=True,
+            ):
+                st.session_state.session_downloaded = True

interface/components/gallery.py

@@ -0,0 +1,106 @@
+"""OphthalmoCapture — Image Gallery Component
+
+Renders a thumbnail strip of all uploaded images with labeling-status
+badges and click-to-select behaviour.
+"""
+
+import streamlit as st
+from services import session_manager as sm
+
+
+def _label_badge(label):
+    """Return a coloured status indicator for the label value."""
+    if label is None:
+        return "🔴"   # unlabeled
+    return "🟢"       # labeled (any value)
+
+
+def render_gallery():
+    """Draw the horizontal thumbnail gallery with status badges.
+
+    Returns True if the user clicked on a thumbnail (triggers rerun).
+    """
+    images = st.session_state.images
+    order = st.session_state.image_order
+    current_id = st.session_state.current_image_id
+
+    if not order:
+        return False
+
+    # ── Progress bar ─────────────────────────────────────────────────────
+    labeled, total = sm.get_labeling_progress()
+    progress_text = f"Progreso: **{labeled}** / **{total}** etiquetadas"
+    st.markdown(progress_text)
+    st.progress(labeled / total if total > 0 else 0)
+
+    # ── Thumbnail strip ──────────────────────────────────────────────────
+    # Show up to 8 thumbnails per row; wrap if there are more.
+    COLS_PER_ROW = 8
+    num_images = len(order)
+
+    # Paginate the gallery if many images
+    if "gallery_page" not in st.session_state:
+        st.session_state.gallery_page = 0
+
+    total_pages = max(1, -(-num_images // COLS_PER_ROW))  # ceil division
+    page = st.session_state.gallery_page
+    start = page * COLS_PER_ROW
+    end = min(start + COLS_PER_ROW, num_images)
+    visible_ids = order[start:end]
+
+    cols = st.columns(max(len(visible_ids), 1))
+
+    clicked = False
+    for i, img_id in enumerate(visible_ids):
+        img = images[img_id]
+        badge = _label_badge(img["label"])
+        is_selected = (img_id == current_id)
+
+        with cols[i]:
+            # Visual border to highlight the selected thumbnail
+            if is_selected:
+                st.markdown(
+                    "<div style='border:3px solid #4CAF50; border-radius:8px; "
+                    "padding:2px;'>",
+                    unsafe_allow_html=True,
+                )
+
+            st.image(img["bytes"], use_container_width=True)
+
+            if is_selected:
+                st.markdown("</div>", unsafe_allow_html=True)
+
+            # Label + filename
+            short_name = img["filename"]
+            if len(short_name) > 18:
+                short_name = short_name[:15] + "…"
+
+            if st.button(
+                f"{badge} {short_name}",
+                key=f"thumb_{img_id}",
+                use_container_width=True,
+            ):
+                sm.set_current_image(img_id)
+                clicked = True
+
+    # ── Gallery pagination ───────────────────────────────────────────────
+    if total_pages > 1:
+        gc1, gc2, gc3 = st.columns([1, 3, 1])
+        with gc1:
+            if page > 0:
+                if st.button("◀ Ant.", 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>",
+                unsafe_allow_html=True,
+            )
+        with gc3:
+            if page < total_pages - 1:
+                if st.button("Sig. ▶", key="gal_next"):
+                    st.session_state.gallery_page += 1
+                    clicked = True
+
+    return clicked

interface/components/image_protection.py

@@ -0,0 +1,177 @@
+"""OphthalmoCapture — Image Protection Layer
+
+Injects CSS and JavaScript into the Streamlit page to prevent users from
+downloading, dragging, or otherwise saving the confidential medical images.
+
+KEY DESIGN DECISION:
+  Streamlit's st.markdown(unsafe_allow_html=True) renders <style> tags but
+  STRIPS <script> tags for security.  Therefore:
+    • CSS protections → injected via st.markdown (works natively).
+    • JS  protections → injected via st.components.v1.html() which creates
+      a real iframe where JavaScript executes.  From that iframe we reach
+      the main Streamlit page via window.parent.document (same-origin).
+
+Protection layers (defence-in-depth):
+  1. CSS: pointer-events:none, user-select:none, draggable:false on <img>.
+  2. CSS: transparent ::after overlay on stImage containers blocks
+     right-click "Save image as…".
+  3. CSS: -webkit-touch-callout:none blocks mobile long-press save.
+  4. JS:  contextmenu event blocked on the ENTIRE parent document.
+  5. JS:  Ctrl+S / Ctrl+U / Ctrl+Shift+I / Ctrl+Shift+J / Ctrl+Shift+C /
+         F12 all intercepted and cancelled.
+  6. JS:  dragstart blocked for all images.
+  7. JS:  MutationObserver re-applies draggable=false to dynamically added
+         images (Streamlit re-renders on every interaction).
+  8. JS:  Blob/URL revocation — monkey-patches URL.createObjectURL and
+         document.createElement to block programmatic image extraction.
+
+IMPORTANT LIMITATION:
+  No client-side measure can guarantee absolute prevention.  A technically
+  sophisticated user could still extract images through OS-level screenshots,
+  network packet inspection, or browser extensions that bypass JS hooks.
+  These protections eliminate ALL standard browser download paths and raise
+  the bar significantly.
+"""
+
+import streamlit as st
+import streamlit.components.v1 as components
+
+# ── CSS injected via st.markdown (Streamlit renders <style> natively) ────────
+_PROTECTION_CSS = """
+<style>
+/* Layer 1: Disable ALL interaction on <img> tags */
+img {
+    pointer-events: none       !important;
+    user-select: none          !important;
+    -webkit-user-select: none  !important;
+    -moz-user-select: none     !important;
+    -ms-user-select: none      !important;
+    -webkit-user-drag: none    !important;
+    -webkit-touch-callout: none !important;
+}
+
+/* Layer 2: Transparent overlay on every Streamlit image container */
+[data-testid="stImage"] {
+    position: relative !important;
+}
+[data-testid="stImage"]::after {
+    content: "";
+    position: absolute;
+    top: 0; left: 0; right: 0; bottom: 0;
+    z-index: 10;
+    background: transparent;
+    pointer-events: auto !important;
+    cursor: default;
+}
+
+/* Layer 3: Extra drag prevention */
+[data-testid="stImage"] img {
+    -webkit-user-drag: none !important;
+    user-drag: none         !important;
+}
+</style>
+"""
+
+# ── JavaScript injected via components.html (runs in real iframe) ────────────
+# From the iframe we access window.parent.document to attach listeners
+# on the ACTUAL Streamlit page, not just inside the hidden iframe.
+_PROTECTION_JS_HTML = """
+<script>
+(function () {
+    // The parent document is the real Streamlit page
+    var doc;
+    try { doc = window.parent.document; } catch(e) { doc = document; }
+
+    // Guard: only inject once per page lifecycle
+    if (doc.__ophthalmo_protection__) return;
+    doc.__ophthalmo_protection__ = true;
+
+    function block(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        e.stopImmediatePropagation();
+        return false;
+    }
+
+    // ── Layer 4: Block context menu on ENTIRE page ──────────────────────
+    doc.addEventListener('contextmenu', function (e) {
+        return block(e);
+    }, true);
+
+    // ── Layer 5: Block keyboard shortcuts ───────────────────────────────
+    doc.addEventListener('keydown', function (e) {
+        var dominated = false;
+        var ctrl = e.ctrlKey || e.metaKey;
+        var key  = e.key ? e.key.toLowerCase() : '';
+
+        // Ctrl+S  — Save page
+        if (ctrl && key === 's') dominated = true;
+        // Ctrl+U  — View source
+        if (ctrl && key === 'u') dominated = true;
+        // Ctrl+P  — Print (can save as PDF with images)
+        if (ctrl && key === 'p') dominated = true;
+        // F12     — DevTools
+        if (e.keyCode === 123) dominated = true;
+        // Ctrl+Shift+I — DevTools (Inspector)
+        if (ctrl && e.shiftKey && key === 'i') dominated = true;
+        // Ctrl+Shift+J — DevTools (Console)
+        if (ctrl && e.shiftKey && key === 'j') dominated = true;
+        // Ctrl+Shift+C — DevTools (Element picker)
+        if (ctrl && e.shiftKey && key === 'c') dominated = true;
+
+        if (dominated) return block(e);
+    }, true);
+
+    // ── Layer 6: Block drag-and-drop of images ─────────────────────────
+    doc.addEventListener('dragstart', function (e) {
+        if (e.target && e.target.tagName === 'IMG') return block(e);
+    }, true);
+
+    // ── Layer 7: MutationObserver — lock new images as they appear ──────
+    function lockImages(root) {
+        var imgs = (root.querySelectorAll) ? root.querySelectorAll('img') : [];
+        for (var i = 0; i < imgs.length; i++) {
+            imgs[i].setAttribute('draggable', 'false');
+            imgs[i].ondragstart = function() { return false; };
+            imgs[i].oncontextmenu = function() { return false; };
+        }
+    }
+    lockImages(doc);
+
+    var obs = new MutationObserver(function (mutations) {
+        for (var m = 0; m < mutations.length; m++) {
+            var nodes = mutations[m].addedNodes;
+            for (var n = 0; n < nodes.length; n++) {
+                if (nodes[n].nodeType === 1) lockImages(nodes[n]);
+            }
+        }
+    });
+    obs.observe(doc.body, { childList: true, subtree: true });
+
+    // ── Layer 8: Neuter Blob URL creation for images ────────────────────
+    // Prevents programmatic extraction via createObjectURL
+    var origCreateObjectURL = URL.createObjectURL;
+    URL.createObjectURL = function(obj) {
+        if (obj instanceof Blob && obj.type && obj.type.startsWith('image/')) {
+            console.warn('[OphthalmoCapture] Blob URL creation blocked for images');
+            return '';
+        }
+        return origCreateObjectURL.call(URL, obj);
+    };
+
+})();
+</script>
+"""
+
+
+def inject_image_protection():
+    """Inject all CSS + JS image-protection layers into the page.
+
+    Call this ONCE near the top of main.py, after st.set_page_config().
+    """
+    # CSS — works natively via st.markdown
+    st.markdown(_PROTECTION_CSS, unsafe_allow_html=True)
+
+    # JS — MUST use components.html so the <script> actually executes.
+    # height=0 makes the iframe invisible.
+    components.html(_PROTECTION_JS_HTML, height=0, scrolling=False)

interface/components/labeler.py

@@ -0,0 +1,82 @@
+"""OphthalmoCapture — Labeling Component
+
+Provides the radio-button selector for classifying images (e.g. catarata /
+no catarata) and persists the choice in the ephemeral session.  The label
+list is driven by config.LABEL_OPTIONS so it can be extended without touching
+this component.
+"""
+
+import streamlit as st
+import config
+import database as db
+from services import session_manager as sm
+
+
+def render_labeler(image_id: str):
+    """Render the labeling panel for the given image.
+
+    Displays a radio selector, saves the label into session state and
+    optionally persists metadata to the audit database.
+    """
+    img = st.session_state.images.get(image_id)
+    if img is None:
+        return
+
+    st.subheader("🏷️ Etiquetado")
+
+    display_options = [opt["display"] for opt in config.LABEL_OPTIONS]
+    current_label = img.get("label")
+
+    # Determine current index (None if unlabeled)
+    if current_label is not None and current_label in display_options:
+        current_index = display_options.index(current_label)
+    else:
+        current_index = None
+
+    # Styled container with radio buttons
+    with st.container(border=True):
+        if current_index is None:
+            st.caption("⬇️ Seleccione una etiqueta para esta imagen")
+
+        selected = st.radio(
+            "Clasificación",
+            display_options,
+            index=current_index,
+            key=f"label_radio_{image_id}",
+            horizontal=True,
+            label_visibility="collapsed",
+        )
+
+    # Map selection
+    new_label = selected if selected in display_options else None
+
+    # Detect change, update session and auto-save to DB
+    if new_label is not None and new_label != current_label:
+        st.session_state.images[image_id]["label"] = new_label
+        st.session_state.images[image_id]["labeled_by"] = st.session_state.get(
+            "doctor_name", ""
+        )
+        sm.update_activity()
+
+        # Auto-save to audit DB (upsert — one record per image per session)
+        try:
+            db.save_or_update_annotation(
+                image_filename=img["filename"],
+                label=new_label,
+                transcription=img.get("transcription", ""),
+                doctor_name=st.session_state.get("doctor_name", ""),
+                session_id=st.session_state.get("session_id", ""),
+            )
+        except Exception:
+            pass  # Non-blocking: audit DB failure should not break labeling
+
+    # ── Visual feedback ──────────────────────────────────────────────────
+    if new_label is None:
+        st.warning("🔴 Sin etiquetar")
+    else:
+        code = "—"
+        for opt in config.LABEL_OPTIONS:
+            if opt["display"] == new_label:
+                code = opt["code"]
+                break
+        st.success(f"🟢 Etiqueta: **{new_label}** (código: {code})")

interface/components/recorder.py

@@ -0,0 +1,186 @@
+"""OphthalmoCapture — Audio Recorder & Transcription Component
+
+Records audio via st.audio_input, transcribes with Whisper, stores the
+audio bytes and transcription in the ephemeral session, and lets the
+doctor edit the transcription or restore the original.
+
+Includes timestamped segments from Whisper for reference.
+"""
+
+import hashlib
+import streamlit as st
+import database as db
+from services import session_manager as sm
+from services.whisper_service import transcribe_audio_with_timestamps, format_timestamp
+
+
+def _audio_fingerprint(audio_bytes: bytes) -> str:
+    """Return a short hash of the audio content for change detection."""
+    return hashlib.md5(audio_bytes).hexdigest()
+
+
+def render_recorder(image_id: str, model, language: str):
+    """Render the audio recording + transcription panel.
+
+    Parameters
+    ----------
+    image_id : str
+        UUID of the currently selected image.
+    model :
+        Loaded Whisper model instance.
+    language : str
+        ISO language code for transcription (e.g. "es").
+    """
+    img = st.session_state.images.get(image_id)
+    if img is None:
+        return
+
+    st.subheader("🎙️ Dictado y Transcripción")
+
+    # ── Audio recording ──────────────────────────────────────────────────
+    audio_wav = st.audio_input(
+        "Grabar 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…"):
+                text, segments = transcribe_audio_with_timestamps(
+                    model, audio_bytes, language
+                )
+
+            # Store in session
+            img["audio_bytes"] = audio_bytes
+
+            # Append (don't overwrite) if there was previous text
+            if img["transcription"]:
+                img["transcription"] += " " + text
+            else:
+                img["transcription"] = text
+
+            # Keep a copy of the raw Whisper output
+            if img["transcription_original"]:
+                img["transcription_original"] += " " + text
+            else:
+                img["transcription_original"] = text
+
+            # Store timestamped segments
+            existing_segments = st.session_state.get(segments_key, [])
+            st.session_state[segments_key] = existing_segments + segments
+
+            # Mark this audio as processed using content hash (stable across reruns)
+            st.session_state[processed_key] = fingerprint
+            # Update the text_area widget state so it reflects the new text
+            st.session_state[f"transcription_area_{image_id}"] = img["transcription"]
+
+            # Re-save to audit DB if the image is already labeled (upsert)
+            if img.get("label"):
+                try:
+                    db.save_or_update_annotation(
+                        image_filename=img["filename"],
+                        label=img["label"],
+                        transcription=img["transcription"],
+                        doctor_name=st.session_state.get("doctor_name", ""),
+                        session_id=st.session_state.get("session_id", ""),
+                    )
+                except Exception:
+                    pass
+
+            sm.update_activity()
+            st.rerun()
+
+    # ── Editable transcription ───────────────────────────────────────────
+    edited_text = st.text_area(
+        "Transcripción (editable)",
+        value=img["transcription"],
+        height=180,
+        key=f"transcription_area_{image_id}",
+        placeholder="Grabe un audio o escriba la transcripción manualmente…",
+    )
+
+    # Sync edits back to session
+    if edited_text != img["transcription"]:
+        img["transcription"] = edited_text
+        sm.update_activity()
+
+    # ── Timestamped segments (Idea C) ────────────────────────────────────
+    segments = st.session_state.get(segments_key, [])
+    if segments:
+        with st.expander("🕐 Segmentos con timestamps", expanded=False):
+            for seg in segments:
+                ts_start = format_timestamp(seg["start"])
+                ts_end = format_timestamp(seg["end"])
+                st.markdown(
+                    f"`{ts_start} → {ts_end}`   {seg['text']}"
+                )
+
+    # ── Helper buttons ────────────────────────────��──────────────────────
+    btn_cols = st.columns(3)
+
+    with btn_cols[0]:
+        # Re-record: clear audio and transcription so a new recording can be made
+        has_audio = img["audio_bytes"] is not None
+        if st.button(
+            "🎤 Volver a grabar",
+            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)
+            st.session_state.pop(f"transcription_area_{image_id}", None)
+            # Clear the audio_input widget state to reset the recorder
+            st.session_state.pop(f"audio_input_{image_id}", None)
+            sm.update_activity()
+            st.rerun()
+
+    with btn_cols[1]:
+        # Restore original Whisper transcription
+        has_original = bool(img["transcription_original"])
+        is_different = img["transcription"] != img["transcription_original"]
+        if st.button(
+            "🔄 Restaurar original",
+            key=f"restore_{image_id}",
+            disabled=not (has_original and is_different),
+            use_container_width=True,
+        ):
+            img["transcription"] = 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"] = ""
+            sm.update_activity()
+            st.rerun()
+
+    # ── Status line ──────────────────────────────────────────────────────
+    if img["transcription"]:
+        modified_tag = ""
+        if (
+            img["transcription_original"]
+            and img["transcription"] != img["transcription_original"]
+        ):
+            modified_tag = "  ✏️ _modificada manualmente_"
+        word_count = len(img["transcription"].split())
+        st.caption(f"{word_count} palabras{modified_tag}")
+    else:
+        st.caption("Sin transcripción aún.")

interface/components/uploader.py

@@ -0,0 +1,257 @@
+"""OphthalmoCapture — Image Upload Component
+
+Handles file upload, validation, and ingestion into the ephemeral session.
+Uses @st.dialog modals to warn about:
+  - Previously labeled images (from DB) — doctor chooses which to re-label.
+  - Session duplicates — informational notice.
+"""
+
+import streamlit as st
+import config
+import database as db
+from services import session_manager as sm
+from utils import validate_image_bytes
+
+
+def _reset_uploader():
+    """Increment the uploader key counter to clear the file_uploader widget."""
+    st.session_state._uploader_counter = st.session_state.get("_uploader_counter", 0) + 1
+
+
+# ── 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.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()
+
+
+def _process_pending(relabel_choices: dict[str, bool]):
+    """Ingest accepted files from the pending review."""
+    pending = st.session_state.pop("_pending_upload_review", None)
+    if not pending:
+        st.rerun()
+        return
+
+    prev = pending["previously_labeled"]
+    files_dict = pending["files"]
+    existing_filenames = {
+        img["filename"] for img in st.session_state.images.values()
+    }
+
+    if "_processed_uploads" not in st.session_state:
+        st.session_state._processed_uploads = set()
+
+    added = 0
+    for fname, raw_bytes in files_dict.items():
+        # If it was previously labeled and doctor unchecked it → skip
+        if fname in prev and not relabel_choices.get(fname, True):
+            continue
+        if fname not in existing_filenames:
+            sm.add_image(fname, raw_bytes)
+            st.session_state._processed_uploads.add(fname)
+            st.session_state.session_downloaded = False
+            added += 1
+
+    _reset_uploader()
+    if added > 0 and st.session_state.current_image_id is None:
+        st.session_state.current_image_id = st.session_state.image_order[0]
+    st.rerun()
+
+
+def _cancel_pending():
+    """Cancel previously-labeled images but still ingest new (non-labeled) ones."""
+    pending = st.session_state.pop("_pending_upload_review", None)
+    if pending:
+        prev = pending["previously_labeled"]
+        files_dict = pending["files"]
+        existing_filenames = {
+            img["filename"] for img in st.session_state.images.values()
+        }
+        if "_processed_uploads" not in st.session_state:
+            st.session_state._processed_uploads = set()
+
+        added = 0
+        for fname, raw_bytes in files_dict.items():
+            # Skip previously labeled — doctor chose to cancel them
+            if fname in prev:
+                continue
+            if fname not in existing_filenames:
+                sm.add_image(fname, raw_bytes)
+                st.session_state._processed_uploads.add(fname)
+                st.session_state.session_downloaded = False
+                added += 1
+
+        if added > 0 and st.session_state.current_image_id is None:
+            st.session_state.current_image_id = st.session_state.image_order[0]
+
+    _reset_uploader()
+    st.rerun()
+
+
+# ── 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}`")
+
+    if st.button("Aceptar", use_container_width=True):
+        st.session_state.pop("_session_duplicates", None)
+        st.rerun()
+
+
+# ── Main uploader ────────────────────────────────────────────────────────────
+def render_uploader():
+    """Render the file uploader and process new uploads.
+
+    Returns the number of newly added images (0 if none).
+    """
+    counter = st.session_state.get("_uploader_counter", 0)
+
+    uploaded_files = st.file_uploader(
+        "📤 Subir imágenes médicas",
+        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.",
+        key=f"uploader_{counter}",
+    )
+
+    # ── Show pending dialogs (survive reruns) ────────────────────────────
+    if "_pending_upload_review" in st.session_state:
+        _show_relabel_dialog()
+        return 0
+
+    if "_session_duplicates" in st.session_state:
+        _show_duplicates_dialog()
+        return 0
+
+    if not uploaded_files:
+        return 0
+
+    if "_processed_uploads" not in st.session_state:
+        st.session_state._processed_uploads = set()
+
+    existing_filenames = {
+        img["filename"] for img in st.session_state.images.values()
+    }
+
+    # ── Classify files ───────────────────────────────────────────────────
+    new_files = []
+    skipped_invalid = 0
+    session_duplicates = []
+
+    for uf in uploaded_files:
+        # Already in the current session
+        if uf.name in existing_filenames:
+            if uf.name not in st.session_state._processed_uploads:
+                session_duplicates.append(uf.name)
+                st.session_state._processed_uploads.add(uf.name)
+            continue
+
+        # Already ingested via this uploader cycle
+        if uf.name in st.session_state._processed_uploads:
+            continue
+
+        raw_bytes = uf.getvalue()
+        if not validate_image_bytes(raw_bytes):
+            skipped_invalid += 1
+            continue
+
+        new_files.append((uf.name, raw_bytes))
+
+    # ── Check DB for previously labeled images ───────────────────────────
+    if new_files:
+        new_filenames = [name for name, _ in new_files]
+        previously_labeled = db.get_previously_labeled_filenames(new_filenames)
+
+        if previously_labeled:
+            # Store all files (new + previously labeled) for review
+            st.session_state["_pending_upload_review"] = {
+                "files": {name: raw for name, raw in new_files},
+                "previously_labeled": previously_labeled,
+            }
+            # Also show session duplicate dialog afterward if needed
+            if session_duplicates:
+                st.session_state["_session_duplicates"] = session_duplicates
+            st.rerun()
+            return 0
+
+    # ── Ingest files that need no review ─────────────────────────────────
+    new_count = 0
+    for name, raw_bytes in new_files:
+        if name in existing_filenames:
+            continue
+        if name in st.session_state._processed_uploads:
+            continue
+
+        sm.add_image(name, raw_bytes)
+        existing_filenames.add(name)
+        st.session_state._processed_uploads.add(name)
+        st.session_state.session_downloaded = False
+        new_count += 1
+
+    if skipped_invalid > 0:
+        st.warning(
+            f"⚠️ {skipped_invalid} archivo(s) no son imágenes válidas y fueron ignorados."
+        )
+
+    if new_count > 0:
+        _reset_uploader()
+        if st.session_state.current_image_id is None:
+            st.session_state.current_image_id = st.session_state.image_order[0]
+
+    # ── Show session duplicate info dialog if any ────────────────────────
+    if session_duplicates:
+        st.session_state["_session_duplicates"] = session_duplicates
+        st.rerun()
+
+    return new_count

interface/config.py

@@ -0,0 +1,38 @@
+"""OphthalmoCapture — Configuration Constants."""
+
+# ── Label Options ────────────────────────────────────────────────────────────
+# Designed as a configurable list for easy extension (e.g. glaucoma, DR, AMD).
+LABEL_OPTIONS = [
+    {"key": "catarata",    "display": "Catarata",    "code": 1},
+    {"key": "no_catarata", "display": "No Catarata", "code": 0},
+]
+
+# ── Session Settings ─────────────────────────────────────────────────────────
+SESSION_TIMEOUT_MINUTES = 30
+
+# ── Upload Settings ──────────────────────────────────────────────────────────
+ALLOWED_EXTENSIONS = ["jpg", "jpeg", "png", "tif"]
+MAX_UPLOAD_SIZE_MB = 50
+
+# ── Whisper Settings ─────────────────────────────────────────────────────────
+WHISPER_MODEL_OPTIONS = [
+    "tiny", "tiny.en", "base", "base.en",
+    "small", "small.en", "medium", "medium.en",
+    "large", "turbo",
+]
+DEFAULT_WHISPER_MODEL_INDEX = 1
+
+WHISPER_LANGUAGE_OPTIONS = {
+    "es": "Español",
+    "en": "English",
+}
+DEFAULT_WHISPER_LANGUAGE = "es"
+
+# ── App Metadata ─────────────────────────────────────────────────────────────
+APP_TITLE = "OphthalmoCapture"
+APP_ICON = "👁️"
+APP_SUBTITLE = "Sistema de Etiquetado Médico Oftalmológico"
+
+# ── UI Language ──────────────────────────────────────────────────────────────
+# "es" = Español, "en" = English
+UI_LANGUAGE = "es"

interface/database.py

@@ -1,7 +1,12 @@
+"""OphthalmoCapture — Database Layer (Metadata Only)
+
+Option B: The database persists annotation metadata (labels, transcriptions,
+doctor info, timestamps) for audit and history.  It NEVER stores images or audio.
+"""
+
 import os
 import datetime
 import sqlite3
-import math
 
 # Try importing firebase_admin
 try:
@@ -12,12 +17,14 @@ except ImportError:
     FIREBASE_AVAILABLE = False
 
 DB_TYPE = "SQLITE"
+DB_FILE = "annotations.db"
 db_ref = None
 
+
 def init_db():
-    """Initializes the database connection (Firebase or SQLite)."""
+    """Initialize the database connection (Firebase or SQLite fallback)."""
     global DB_TYPE, db_ref
-    
+
     # Try Firebase first
     if FIREBASE_AVAILABLE and os.path.exists("serviceAccountKey.json"):
         try:
@@ -32,14 +39,25 @@ def init_db():
 
     # Fallback to SQLite
     try:
-        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
         c = conn.cursor()
-        c.execute('''CREATE TABLE IF NOT EXISTS diagnoses
-                     (id INTEGER PRIMARY KEY AUTOINCREMENT, 
-                      image_id TEXT, 
-                      diagnosis_text TEXT, 
-                      timestamp DATETIME)''')
-        c.execute('''CREATE INDEX IF NOT EXISTS idx_image_id ON diagnoses (image_id)''')
+        c.execute('''CREATE TABLE IF NOT EXISTS annotations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            image_filename TEXT NOT NULL,
+            label TEXT,
+            transcription TEXT,
+            doctor_name TEXT DEFAULT '',
+            created_at DATETIME
+        )''')
+        c.execute('''CREATE INDEX IF NOT EXISTS idx_ann_filename
+                      ON annotations (image_filename)''')
+        # Migration: add session_id column if it doesn't exist yet
+        try:
+            c.execute("ALTER TABLE annotations ADD COLUMN session_id TEXT DEFAULT ''")
+        except sqlite3.OperationalError:
+            pass  # column already exists
+        c.execute('''CREATE INDEX IF NOT EXISTS idx_ann_session
+                      ON annotations (image_filename, session_id)''')
         conn.commit()
         conn.close()
         DB_TYPE = "SQLITE"
@@ -47,123 +65,390 @@ def init_db():
     except Exception as e:
         raise Exception(f"Database initialization failed: {e}")
 
-def save_diagnosis(image_id, text, doctor_name="LocalUser"):
-    """Saves the diagnosis to the active database."""
+
+def save_annotation(image_filename, label, transcription, doctor_name=""):
+    """Save an annotation record (always INSERT).  Stores metadata only."""
     timestamp = datetime.datetime.now()
-    
+
     if DB_TYPE == "FIREBASE":
-        db_ref.collection("ophthalmo_diagnoses").add({
-            "imageId": image_id,
-            "diagnosisText": text,
+        db_ref.collection("annotations").add({
+            "imageFilename": image_filename,
+            "label": label,
+            "transcription": transcription,
+            "doctorName": doctor_name,
             "createdAt": timestamp,
-            "doctor": doctor_name
         })
     else:
-        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
+        c = conn.cursor()
+        c.execute(
+            "INSERT INTO annotations "
+            "(image_filename, label, transcription, doctor_name, created_at) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (image_filename, label, transcription, doctor_name, timestamp),
+        )
+        conn.commit()
+        conn.close()
+
+
+def save_or_update_annotation(
+    image_filename, label, transcription, doctor_name="", session_id=""
+):
+    """Upsert: within the same session, keep only ONE record per image.
+
+    If a record for (image_filename, session_id) already exists → UPDATE it.
+    Otherwise → INSERT a new one.
+    """
+    timestamp = datetime.datetime.now()
+
+    if DB_TYPE == "FIREBASE":
+        # Query for existing doc with matching filename + session
+        docs = list(
+            db_ref.collection("annotations")
+            .where("imageFilename", "==", image_filename)
+            .where("sessionId", "==", session_id)
+            .limit(1)
+            .stream()
+        )
+        if docs:
+            docs[0].reference.update({
+                "label": label,
+                "transcription": transcription,
+                "doctorName": doctor_name,
+                "createdAt": timestamp,
+            })
+        else:
+            db_ref.collection("annotations").add({
+                "imageFilename": image_filename,
+                "label": label,
+                "transcription": transcription,
+                "doctorName": doctor_name,
+                "sessionId": session_id,
+                "createdAt": timestamp,
+            })
+    else:
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
         c = conn.cursor()
-        c.execute("INSERT INTO diagnoses (image_id, diagnosis_text, timestamp) VALUES (?, ?, ?)",
-                  (image_id, text, timestamp))
+        # Check if a row for this image+session already exists
+        c.execute(
+            "SELECT id FROM annotations "
+            "WHERE image_filename = ? AND session_id = ? LIMIT 1",
+            (image_filename, session_id),
+        )
+        row = c.fetchone()
+        if row:
+            c.execute(
+                "UPDATE annotations "
+                "SET label = ?, transcription = ?, doctor_name = ?, created_at = ? "
+                "WHERE id = ?",
+                (label, transcription, doctor_name, timestamp, row[0]),
+            )
+        else:
+            c.execute(
+                "INSERT INTO annotations "
+                "(image_filename, label, transcription, doctor_name, created_at, session_id) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (image_filename, label, transcription, doctor_name, timestamp, session_id),
+            )
         conn.commit()
         conn.close()
 
-def get_latest_diagnosis(image_id):
-    """Retrieves the most recent diagnosis for a specific image ID."""
+
+def get_latest_annotation(image_filename):
+    """Retrieve the most recent annotation for a given image filename."""
     if DB_TYPE == "FIREBASE":
-        docs = db_ref.collection("ophthalmo_diagnoses")\
-            .where("imageId", "==", image_id)\
-            .order_by("createdAt", direction=firestore.Query.DESCENDING)\
-            .limit(1)\
+        docs = (
+            db_ref.collection("annotations")
+            .where("imageFilename", "==", image_filename)
+            .order_by("createdAt", direction=firestore.Query.DESCENDING)
+            .limit(1)
             .stream()
+        )
         for doc in docs:
-            return doc.to_dict().get("diagnosisText", "")
+            return doc.to_dict()
+        return None
     else:
-        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
         c = conn.cursor()
-        c.execute("SELECT diagnosis_text FROM diagnoses WHERE image_id = ? ORDER BY id DESC LIMIT 1", (image_id,))
+        c.execute(
+            "SELECT image_filename, label, transcription, doctor_name, created_at "
+            "FROM annotations WHERE image_filename = ? ORDER BY id DESC LIMIT 1",
+            (image_filename,),
+        )
         row = c.fetchone()
         conn.close()
         if row:
-            return row[0]
-    return ""
+            return {
+                "imageFilename": row[0],
+                "label": row[1],
+                "transcription": row[2],
+                "doctorName": row[3],
+                "createdAt": row[4],
+            }
+        return None
+
 
 def get_history_paginated(search_query="", page=1, per_page=10):
-    """
-    Retrieves history with search filtering and pagination.
+    """Retrieve annotation history with search and pagination.
+
     Returns: (list_of_items, total_count)
     """
     offset = (page - 1) * per_page
     history = []
     total_count = 0
-    
+
     if DB_TYPE == "FIREBASE":
-        ref = db_ref.collection("ophthalmo_diagnoses")
+        ref = db_ref.collection("annotations")
         if search_query:
-            # Prefix search hack for Firestore
-            query = ref.where("imageId", ">=", search_query)\
-                       .where("imageId", "<=", search_query + '\uf8ff')
+            query = (
+                ref.where("imageFilename", ">=", search_query)
+                .where("imageFilename", "<=", search_query + "\uf8ff")
+            )
         else:
             query = ref.order_by("createdAt", direction=firestore.Query.DESCENDING)
-        
+
         all_docs = list(query.stream())
         total_count = len(all_docs)
-        
-        # In-memory pagination for Firebase
-        start = offset
-        end = offset + per_page
-        for doc in all_docs[start:end]:
+        for doc in all_docs[offset : offset + per_page]:
             history.append(doc.to_dict())
 
     else:
-        # SQLite Implementation
-        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
         c = conn.cursor()
-        
-        # 1. Count
+
+        # Count
         if search_query:
-            c.execute("SELECT COUNT(*) FROM diagnoses WHERE image_id LIKE ?", (f"%{search_query}%",))
+            c.execute(
+                "SELECT COUNT(*) FROM annotations WHERE image_filename LIKE ?",
+                (f"%{search_query}%",),
+            )
         else:
-            c.execute("SELECT COUNT(*) FROM diagnoses")
+            c.execute("SELECT COUNT(*) FROM annotations")
         total_count = c.fetchone()[0]
-        
-        # 2. Fetch
-        query_sql = "SELECT image_id, diagnosis_text, timestamp FROM diagnoses"
+
+        # Fetch page
+        sql = (
+            "SELECT image_filename, label, transcription, doctor_name, created_at "
+            "FROM annotations"
+        )
         params = []
-        
         if search_query:
-            query_sql += " WHERE image_id LIKE ?"
+            sql += " WHERE image_filename LIKE ?"
             params.append(f"%{search_query}%")
-            
-        query_sql += " ORDER BY id DESC LIMIT ? OFFSET ?"
+        sql += " ORDER BY id DESC LIMIT ? OFFSET ?"
         params.extend([per_page, offset])
-        
-        c.execute(query_sql, params)
-        rows = c.fetchall()
-        for row in rows:
+
+        c.execute(sql, params)
+        for row in c.fetchall():
             history.append({
-                "imageId": row[0],
-                "diagnosisText": row[1],
-                "createdAt": row[2]
+                "imageFilename": row[0],
+                "label": row[1],
+                "transcription": row[2],
+                "doctorName": row[3],
+                "createdAt": row[4],
             })
         conn.close()
-        
+
     return history, total_count
 
-def get_last_active_image_id():
-    """Retrieves the image_id of the most recently saved diagnosis."""
+
+def get_annotation_stats():
+    """Get summary statistics of all stored annotations."""
     if DB_TYPE == "FIREBASE":
-        docs = db_ref.collection("ophthalmo_diagnoses")\
-            .order_by("createdAt", direction=firestore.Query.DESCENDING)\
-            .limit(1)\
-            .stream()
+        docs = list(db_ref.collection("annotations").stream())
+        total = len(docs)
+        labels = {}
         for doc in docs:
-            return doc.to_dict().get("imageId")
+            lbl = doc.to_dict().get("label", "sin_etiqueta")
+            labels[lbl] = labels.get(lbl, 0) + 1
+        return {"total": total, "by_label": labels}
     else:
-        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
         c = conn.cursor()
-        # Fetch the most recent entry based on timestamp (or ID if timestamp is unreliable)
-        c.execute("SELECT image_id FROM diagnoses ORDER BY timestamp DESC LIMIT 1")
-        row = c.fetchone()
+        c.execute("SELECT COUNT(*) FROM annotations")
+        total = c.fetchone()[0]
+        c.execute("SELECT label, COUNT(*) FROM annotations GROUP BY label")
+        labels = {row[0]: row[1] for row in c.fetchall()}
         conn.close()
-        if row:
-            return row[0]
-    return None
+        return {"total": total, "by_label": labels}
+
+
+def get_previously_labeled_filenames(filenames: list[str]) -> dict[str, list[dict]]:
+    """Check which filenames have been previously annotated in the DB.
+
+    Returns a dict mapping filename → list of annotation records.
+    Only filenames with at least one record are included.
+    """
+    if not filenames:
+        return {}
+
+    result = {}
+
+    if DB_TYPE == "FIREBASE":
+        # Firestore doesn't support 'IN' with >30 items, so batch
+        for fname in filenames:
+            docs = (
+                db_ref.collection("annotations")
+                .where("imageFilename", "==", fname)
+                .order_by("createdAt", direction=firestore.Query.DESCENDING)
+                .stream()
+            )
+            records = [doc.to_dict() for doc in docs]
+            if records:
+                result[fname] = records
+    else:
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
+        c = conn.cursor()
+        placeholders = ",".join("?" for _ in filenames)
+        c.execute(
+            f"SELECT image_filename, label, transcription, doctor_name, created_at "
+            f"FROM annotations WHERE image_filename IN ({placeholders}) "
+            f"ORDER BY created_at DESC",
+            filenames,
+        )
+        for row in c.fetchall():
+            fname = row[0]
+            record = {
+                "imageFilename": row[0],
+                "label": row[1],
+                "transcription": row[2],
+                "doctorName": row[3],
+                "createdAt": row[4],
+            }
+            result.setdefault(fname, []).append(record)
+        conn.close()
+
+    return result
+
+
+def get_all_annotations_for_file(image_filename: str) -> list[dict]:
+    """Retrieve ALL annotations for a given image filename, ordered by date desc."""
+    if DB_TYPE == "FIREBASE":
+        docs = (
+            db_ref.collection("annotations")
+            .where("imageFilename", "==", image_filename)
+            .order_by("createdAt", direction=firestore.Query.DESCENDING)
+            .stream()
+        )
+        return [doc.to_dict() for doc in docs]
+    else:
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
+        c = conn.cursor()
+        c.execute(
+            "SELECT image_filename, label, transcription, doctor_name, created_at "
+            "FROM annotations WHERE image_filename = ? ORDER BY created_at DESC",
+            (image_filename,),
+        )
+        results = []
+        for row in c.fetchall():
+            results.append({
+                "imageFilename": row[0],
+                "label": row[1],
+                "transcription": row[2],
+                "doctorName": row[3],
+                "createdAt": row[4],
+            })
+        conn.close()
+        return results
+
+
+def get_history_grouped(search_query="", page=1, per_page=10):
+    """Retrieve annotation history GROUPED by image filename.
+
+    Returns: (list_of_groups, total_unique_images)
+    Each group = {"imageFilename": str, "annotations": [list of records]}
+    sorted by most recent annotation date per image.
+    """
+    offset = (page - 1) * per_page
+
+    if DB_TYPE == "FIREBASE":
+        ref = db_ref.collection("annotations")
+        if search_query:
+            query = (
+                ref.where("imageFilename", ">=", search_query)
+                .where("imageFilename", "<=", search_query + "\uf8ff")
+            )
+        else:
+            query = ref.order_by("createdAt", direction=firestore.Query.DESCENDING)
+
+        all_docs = [doc.to_dict() for doc in query.stream()]
+
+        # Group by filename
+        grouped = {}
+        for doc in all_docs:
+            fname = doc.get("imageFilename", "")
+            grouped.setdefault(fname, []).append(doc)
+
+        # Sort groups by most recent annotation
+        sorted_groups = sorted(
+            grouped.items(),
+            key=lambda x: max(str(a.get("createdAt", "")) for a in x[1]),
+            reverse=True,
+        )
+
+        total_unique = len(sorted_groups)
+        page_groups = sorted_groups[offset:offset + per_page]
+
+        result = []
+        for fname, annotations in page_groups:
+            result.append({
+                "imageFilename": fname,
+                "annotations": sorted(
+                    annotations,
+                    key=lambda a: str(a.get("createdAt", "")),
+                    reverse=True,
+                ),
+            })
+
+        return result, total_unique
+    else:
+        conn = sqlite3.connect(DB_FILE, check_same_thread=False)
+        c = conn.cursor()
+
+        # Count unique filenames
+        where = ""
+        params = []
+        if search_query:
+            where = " WHERE image_filename LIKE ?"
+            params.append(f"%{search_query}%")
+
+        c.execute(
+            f"SELECT COUNT(DISTINCT image_filename) FROM annotations{where}",
+            params,
+        )
+        total_unique = c.fetchone()[0]
+
+        # Get unique filenames for this page, sorted by most recent
+        c.execute(
+            f"SELECT image_filename, MAX(created_at) as latest "
+            f"FROM annotations{where} "
+            f"GROUP BY image_filename ORDER BY latest DESC "
+            f"LIMIT ? OFFSET ?",
+            params + [per_page, offset],
+        )
+        page_filenames = [row[0] for row in c.fetchall()]
+
+        # Fetch all annotations for those filenames
+        result = []
+        for fname in page_filenames:
+            c.execute(
+                "SELECT image_filename, label, transcription, doctor_name, created_at "
+                "FROM annotations WHERE image_filename = ? ORDER BY created_at DESC",
+                (fname,),
+            )
+            annotations = []
+            for row in c.fetchall():
+                annotations.append({
+                    "imageFilename": row[0],
+                    "label": row[1],
+                    "transcription": row[2],
+                    "doctorName": row[3],
+                    "createdAt": row[4],
+                })
+            result.append({
+                "imageFilename": fname,
+                "annotations": annotations,
+            })
+
+        conn.close()
+        return result, total_unique

interface/i18n.py

@@ -0,0 +1,182 @@
+"""OphthalmoCapture — Internationalization (i18n)
+
+Centralized UI strings. Switch the active language by changing
+``ACTIVE_LANGUAGE``.  All components import strings from here.
+"""
+
+ACTIVE_LANGUAGE = "es"
+
+_STRINGS = {
+    "es": {
+        # App
+        "app_subtitle": "Sistema de Etiquetado Médico Oftalmológico",
+        # Sidebar
+        "settings": "⚙️ Configuración",
+        "doctor_name": "👨‍⚕️ Nombre del Doctor",
+        "whisper_model": "Modelo Whisper",
+        "dictation_language": "Idioma de dictado",
+        "current_session": "📊 Sesión Actual",
+        "db_type": "Base de datos",
+        "images_loaded": "Imágenes cargadas",
+        "labeled_count": "Etiquetadas",
+        "no_images": "No hay imágenes en la sesión.",
+        "history": "🗄️ Historial",
+        "search_image": "🔍 Buscar por imagen",
+        "no_records": "Sin registros.",
+        "label_header": "Etiqueta",
+        "doctor_header": "Doctor",
+        "no_transcription": "Sin transcripción",
+        "end_session": "🗑️ Finalizar 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",
+        "cancel": "❌ Cancelar",
+        "logout": "🚪 Cerrar sesión",
+        # Upload
+        "upload_images": "📤 Subir imágenes médicas",
+        "upload_help_formats": "Formatos aceptados",
+        "upload_help_max": "Máx.",
+        "invalid_files": "archivo(s) no son imágenes válidas y fueron ignorados.",
+        "duplicate_files": "archivo(s) duplicados fueron omitidos.",
+        "upload_prompt": "📤 Suba imágenes médicas para comenzar el etiquetado.",
+        # Gallery
+        "progress": "Progreso",
+        "labeled_suffix": "etiquetadas",
+        "page": "Página",
+        # Labeler
+        "labeling": "🏷️ Etiquetado",
+        "select_label": "— Seleccione una etiqueta —",
+        "classification": "Clasificación de la imagen",
+        "unlabeled": "🔴 Sin etiquetar",
+        "label_set": "🟢 Etiqueta",
+        "code": "código",
+        "save_label": "💾 Guardar etiqueta en historial",
+        "select_before_save": "Seleccione una etiqueta antes de guardar.",
+        "label_saved": "✅ Etiqueta guardada en la base de datos.",
+        "save_error": "Error al guardar",
+        # Recorder
+        "dictation": "🎙️ Dictado y Transcripción",
+        "record_audio": "Grabar audio",
+        "transcribing": "Transcribiendo audio…",
+        "transcription_editable": "Transcripción (editable)",
+        "transcription_placeholder": "Grabe un audio o escriba la transcripción manualmente…",
+        "segments_timestamps": "🕐 Segmentos con timestamps",
+        "restore_original": "🔄 Restaurar original",
+        "clear_text": "🗑️ Limpiar texto",
+        "words": "palabras",
+        "manually_modified": "✏️ _modificada manualmente_",
+        "no_transcription_yet": "Sin transcripción aún.",
+        # Downloader
+        "download": "📥 Descarga",
+        "current_image": "Imagen actual",
+        "label_to_enable": "Etiquete la imagen para habilitar la descarga individual.",
+        "download_label": "⬇️ Descargar etiquetado",
+        "full_session": "Toda la sesión",
+        "images_metric": "Imágenes",
+        "with_audio": "Con audio",
+        "labeled_metric": "Etiquetadas",
+        "with_transcription": "Con transcripción",
+        "unlabeled_warning": "imagen(es) sin etiquetar. Se incluirán en la descarga pero sin etiqueta.",
+        "no_images_download": "No hay imágenes para descargar.",
+        "download_all": "⬇️ Descargar todo el etiquetado (ZIP)",
+        "ml_formats": "Formatos para ML",
+        "hf_csv": "📊 CSV (HuggingFace)",
+        "jsonl_finetune": "📄 JSONL (Fine-tuning)",
+        # Nav
+        "previous": "⬅️ Anterior",
+        "next": "Siguiente ➡️",
+        "delete_image": "🗑️ Eliminar esta imagen",
+        # Timeout
+        "session_expired_data": "⏰ Sesión expirada por inactividad",
+        "session_expired_clean": "⏰ Sesión expirada por inactividad. Se inició una nueva sesión.",
+        "download_before_expire": "Descargue sus datos antes de que expire la sesión la próxima vez.",
+        # Auth
+        "login_prompt": "👨‍⚕️ Inicie sesión para acceder al sistema de etiquetado.",
+        "login_error": "❌ Usuario o contraseña incorrectos.",
+    },
+    "en": {
+        "app_subtitle": "Ophthalmological Medical Labeling System",
+        "settings": "⚙️ Settings",
+        "doctor_name": "👨‍⚕️ Doctor Name",
+        "whisper_model": "Whisper Model",
+        "dictation_language": "Dictation Language",
+        "current_session": "📊 Current Session",
+        "db_type": "Database",
+        "images_loaded": "Images loaded",
+        "labeled_count": "Labeled",
+        "no_images": "No images in session.",
+        "history": "🗄️ History",
+        "search_image": "🔍 Search by image",
+        "no_records": "No records.",
+        "label_header": "Label",
+        "doctor_header": "Doctor",
+        "no_transcription": "No transcription",
+        "end_session": "🗑️ End Session",
+        "undownloaded_warning": "⚠️ Undownloaded data",
+        "timeout_in": "⏱️ Timeout in",
+        "confirm_delete": "Are you sure? **All data will be permanently deleted.**",
+        "yes_delete": "✅ Yes, delete",
+        "cancel": "❌ Cancel",
+        "logout": "🚪 Log out",
+        "upload_images": "📤 Upload medical images",
+        "upload_help_formats": "Accepted formats",
+        "upload_help_max": "Max.",
+        "invalid_files": "file(s) are not valid images and were ignored.",
+        "duplicate_files": "duplicate file(s) were skipped.",
+        "upload_prompt": "📤 Upload medical images to start labeling.",
+        "progress": "Progress",
+        "labeled_suffix": "labeled",
+        "page": "Page",
+        "labeling": "🏷️ Labeling",
+        "select_label": "— Select a label —",
+        "classification": "Image classification",
+        "unlabeled": "🔴 Unlabeled",
+        "label_set": "🟢 Label",
+        "code": "code",
+        "save_label": "💾 Save label to history",
+        "select_before_save": "Select a label before saving.",
+        "label_saved": "✅ Label saved to database.",
+        "save_error": "Save error",
+        "dictation": "🎙️ Dictation & Transcription",
+        "record_audio": "Record audio",
+        "transcribing": "Transcribing audio…",
+        "transcription_editable": "Transcription (editable)",
+        "transcription_placeholder": "Record audio or type the transcription manually…",
+        "segments_timestamps": "🕐 Segments with timestamps",
+        "restore_original": "🔄 Restore original",
+        "clear_text": "🗑️ Clear text",
+        "words": "words",
+        "manually_modified": "✏️ _manually modified_",
+        "no_transcription_yet": "No transcription yet.",
+        "download": "📥 Download",
+        "current_image": "Current image",
+        "label_to_enable": "Label the image to enable individual download.",
+        "download_label": "⬇️ Download labeling",
+        "full_session": "Full session",
+        "images_metric": "Images",
+        "with_audio": "With audio",
+        "labeled_metric": "Labeled",
+        "with_transcription": "With transcription",
+        "unlabeled_warning": "unlabeled image(s). They will be included in the download without a label.",
+        "no_images_download": "No images to download.",
+        "download_all": "⬇️ Download all labeling (ZIP)",
+        "ml_formats": "ML Formats",
+        "hf_csv": "📊 CSV (HuggingFace)",
+        "jsonl_finetune": "📄 JSONL (Fine-tuning)",
+        "previous": "⬅️ Previous",
+        "next": "Next ➡️",
+        "delete_image": "🗑️ Delete this image",
+        "session_expired_data": "⏰ Session expired due to inactivity",
+        "session_expired_clean": "⏰ Session expired. A new session has started.",
+        "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.",
+    },
+}
+
+
+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)

interface/main.py

@@ -1,108 +1,183 @@
 import os
-# CRITICAL FIX: MUST BE THE FIRST LINE 
+# CRITICAL FIX: MUST BE THE FIRST LINE
 os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
 
 import streamlit as st
-import tempfile
 import math
+import config
 import database as db
 import utils
+import i18n
+from services import session_manager as sm
+from services.whisper_service import load_whisper_model
+from components.uploader import render_uploader
+from components.gallery import render_gallery
+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
 
-# CONFIGURATION 
-st.set_page_config(page_title="OphthalmoCapture", layout="wide", page_icon="👁️")
+# ── PAGE CONFIG ──────────────────────────────────────────────────────────────
+st.set_page_config(
+    page_title=config.APP_TITLE,
+    layout="wide",
+    page_icon=config.APP_ICON,
+)
+# ── AUTHENTICATION GATE ───────────────────────────────────────────────────────
+if not require_auth():
+    st.stop()
 
-# Change these paths to match your actual folders
-CSV_FILE_PATH = "interface/dataset_fl.csv"  # Your CSV file
-IMAGE_FOLDER = "full-fundus"        # Folder containing your images
+# ── IMAGE PROTECTION (prevent download / right-click save) ───────────────────
+inject_image_protection()
 
-# INITIALIZATION 
-utils.setup_env()
+# Set UI language from config
+i18n.ACTIVE_LANGUAGE = config.UI_LANGUAGE
+# ── SESSION INITIALIZATION ──────────────────────────────────────────────────
+sm.init_session()
+
+# Check inactivity timeout
+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."
+        )
+    else:
+        st.info("⏰ Sesión expirada por inactividad. Se inició una nueva sesión.")
+    sm.clear_session()
+    sm.init_session()
 
+# ── DATABASE (metadata only — never images or audio) ────────────────────────
+utils.setup_env()
 try:
     active_db_type = db.init_db()
 except Exception as e:
-    st.error(f"Critical Database Error: {e}")
+    st.error(f"Error crítico de base de datos: {e}")
     st.stop()
 
-# LOAD REAL DATASET
-# This replaces the mock data. It runs once per session.
-if 'dataset' not in st.session_state:
-    st.session_state.dataset = utils.load_dataset(CSV_FILE_PATH, IMAGE_FOLDER)
+# ── SIDEBAR ──────────────────────────────────────────────────────────────────
+with st.sidebar:
+    st.title("⚙️ Configuración")
 
-# Helper to access the dataset safely
-DATASET = st.session_state.dataset
+    # Logout button (only visible if auth is active)
+    render_logout_button()
 
-if not DATASET:
-    st.error("Please ensure 'dataset.csv' exists and 'images' folder is populated.")
-    st.stop() # Stop execution if no data
+    # Doctor name
+    doctor = st.text_input(
+        "👨‍⚕️ Nombre del Doctor",
+        value=st.session_state.get("doctor_name", ""),
+    )
+    if doctor != st.session_state.get("doctor_name", ""):
+        st.session_state.doctor_name = doctor
+
+    st.divider()
+
+    # 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_language = lang_keys[lang_labels.index(selected_lang_display)]
+
+    # Whisper model — filtered by selected language
+    # Models ending in ".en" → English only.  Others → multilingual.
+    # "large" and "turbo" are multilingual and work for all languages.
+    if selected_language == "en":
+        available_models = [
+            m for m in config.WHISPER_MODEL_OPTIONS
+            if m.endswith(".en") or m in ("large", "turbo")
+        ]
+    else:
+        available_models = [
+            m for m in config.WHISPER_MODEL_OPTIONS if not m.endswith(".en")
+        ]
+    selected_model = st.selectbox(
+        "Modelo Whisper",
+        available_models,
+        index=0,
+    )
 
-# SIDEBAR: SETTINGS & HISTORY 
-with st.sidebar:
-    st.title("⚙️ Settings")
-    
-    # Model Selector
-    model_options = ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large", "turbo"]
-    selected_model = st.selectbox("Whisper Model Size", model_options, index=1)
-    
     st.divider()
-    
-    # History Section
-    st.header(f"🗄️ History ({active_db_type})")
-    
-    search_input = st.text_input("🔍 Search ID", value=st.session_state.get('history_search', ""))
-    if search_input != st.session_state.get('history_search', ""):
+
+    # ── Session progress ─────────────────────────────────────────────────────
+    labeled, total = sm.get_labeling_progress()
+    st.subheader("📊 Sesión Actual")
+    st.caption(f"Base de datos: **{active_db_type}**")
+    if total > 0:
+        st.write(f"Imágenes cargadas: **{total}**")
+        st.write(f"Etiquetadas: **{labeled}** / {total}")
+        st.progress(labeled / total if total > 0 else 0)
+    else:
+        st.info("No hay imágenes en la sesión.")
+
+    st.divider()
+
+    # ── Annotation History (from DB) — Grouped by image ────────────────────────
+    st.subheader("🗄️ Historial")
+    search_input = st.text_input(
+        "🔍 Buscar por imagen",
+        value=st.session_state.get("history_search", ""),
+    )
+    if search_input != st.session_state.get("history_search", ""):
         st.session_state.history_search = search_input
         st.session_state.history_page = 1
         st.rerun()
 
-    if 'history_page' not in st.session_state:
+    if "history_page" not in st.session_state:
         st.session_state.history_page = 1
-        
+
     ITEMS_PER_PAGE = 5
     try:
-        history_data, total_items = db.get_history_paginated(
-            st.session_state.get('history_search', ""), 
-            st.session_state.history_page, 
-            ITEMS_PER_PAGE
+        history_groups, total_items = db.get_history_grouped(
+            st.session_state.get("history_search", ""),
+            st.session_state.history_page,
+            ITEMS_PER_PAGE,
         )
     except Exception as e:
-        st.error(f"Error fetching history: {e}")
-        history_data, total_items = [], 0
-    
-    if not history_data:
-        st.info("No diagnoses found.")
+        st.error(f"Error al obtener historial: {e}")
+        history_groups, total_items = [], 0
+
+    if not history_groups:
+        st.caption("Sin registros.")
     else:
-        for item in history_data:
-            ts = str(item.get('createdAt'))[:16]
-            img_id = item.get('imageId', 'N/A')
-            text = item.get('diagnosisText', '')
-            preview = (text[:50] + '..') if len(text) > 50 else text
-            
-            with st.expander(f"{img_id} ({ts})"):
-                st.caption(ts)
-                st.write(f"_{preview}_")
-                
-                if st.button("Load Report", key=f"load_{item.get('createdAt')}_{img_id}"):
-                     # 1. Update the text
-                     st.session_state.current_transcription = text
-                     
-                     # 2. Find and update the image index
-                     found_index = -1
-                     for idx, data_item in enumerate(DATASET):
-                         if str(data_item['id']) == str(img_id):
-                             found_index = idx
-                             break
-                     
-                     if found_index != -1:
-                         st.session_state.img_index = found_index
-                     else:
-                         st.warning(f"Image ID {img_id} not found in current dataset.")
-                     
-                     st.rerun()
-
-    total_pages = math.ceil(total_items / ITEMS_PER_PAGE)
+        for group in history_groups:
+            fname = group["imageFilename"]
+            annotations = group["annotations"]
+            n_annotations = len(annotations)
+            latest = annotations[0]
+            latest_label = latest.get("label") or "—"
+
+            # Badge showing number of labelings
+            badge = f" ({n_annotations}x)" if n_annotations > 1 else ""
+
+            with st.expander(f"📄 {fname}{badge} — {latest_label}"):
+                for i, ann in enumerate(annotations):
+                    ts = str(ann.get("createdAt", ""))[:16]
+                    label = ann.get("label") or "—"
+                    doctor = ann.get("doctorName") or "—"
+                    text = ann.get("transcription", "") or ""
+                    preview = (text[:60] + "…") if len(text) > 60 else text
+
+                    if n_annotations > 1:
+                        st.markdown(
+                            f"**#{i + 1}** — `{ts}`"
+                        )
+                    st.write(f"**Etiqueta:** {label}")
+                    st.write(f"**Doctor:** {doctor}")
+                    if preview:
+                        st.caption(f"📝 {preview}")
+                    else:
+                        st.caption("_Sin transcripción_")
+
+                    if i < n_annotations - 1:
+                        st.divider()
+
+    total_pages = max(1, math.ceil(total_items / ITEMS_PER_PAGE))
     if total_pages > 1:
-        st.divider()
         c1, c2, c3 = st.columns([1, 2, 1])
         with c1:
             if st.session_state.history_page > 1:
@@ -110,118 +185,145 @@ with st.sidebar:
                     st.session_state.history_page -= 1
                     st.rerun()
         with c2:
-            st.markdown(f"<div style='text-align: center; padding-top: 5px;'>{st.session_state.history_page} / {total_pages}</div>", unsafe_allow_html=True)
+            st.markdown(
+                f"<div style='text-align:center'>"
+                f"{st.session_state.history_page} / {total_pages}</div>",
+                unsafe_allow_html=True,
+            )
         with c3:
             if st.session_state.history_page < total_pages:
                 if st.button("▶️"):
                     st.session_state.history_page += 1
                     st.rerun()
 
-# LOAD MODEL 
-with st.spinner(f"Loading Whisper '{selected_model}' model..."):
-    model = utils.load_whisper_model(selected_model)
+    st.divider()
 
-# SESSION STATE MANAGEMENT 
-if 'img_index' not in st.session_state:
-    # Default to 0
-    start_index = 0
-    
-    # Try to find the last worked-on image from the DB
-    try:
-        last_id = db.get_last_active_image_id()
-        if last_id:
-            # Find the index of this ID in the current DATASET
-            for i, item in enumerate(DATASET):
-                if str(item["id"]) == str(last_id):
-                    start_index = i
-                    break
-    except Exception as e:
-        print(f"Could not restore session: {e}")
-        
-    st.session_state.img_index = start_index
+    # ── End session ──────────────────────────────────────────────────────────
+    if sm.has_undownloaded_data() and not st.session_state.get("session_downloaded", False):
+        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."
+        )
+        st.caption(f"⏱️ Timeout en ~{remaining:.0f} min")
 
-def load_current_image_data():
-    """Updates session state with DB data for the new image."""
-    current_img_id = DATASET[st.session_state.img_index]["id"]
-    try:
-        existing_text = db.get_latest_diagnosis(current_img_id)
-        st.session_state.current_transcription = existing_text if existing_text else ""
-    except Exception as e:
-        st.error(f"Failed to load diagnosis: {e}")
-        st.session_state.current_transcription = ""
-    st.session_state.last_processed_audio = None
+    # Two-step confirmation to prevent accidental data loss
+    if not st.session_state.get("confirm_end_session", False):
+        if st.button(
+            "🗑️ Finalizar Sesión",
+            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.**"
+        )
+        cc1, cc2 = st.columns(2)
+        with cc1:
+            if st.button("✅ Sí, eliminar", type="primary", use_container_width=True):
+                sm.clear_session()
+                st.rerun()
+        with cc2:
+            if st.button("❌ Cancelar", 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}'..."):
+    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.
+if sm.has_undownloaded_data() and not st.session_state.get("session_downloaded", False):
+    st.components.v1.html(
+        """
+        <script>
+        window.addEventListener('beforeunload', function (e) {
+            e.preventDefault();
+            e.returnValue = '';
+        });
+        </script>
+        """,
+        height=0,
+    )
+# ── MAIN CONTENT ───────────────────────────────���─────────────────────────────
+st.title(f"{config.APP_ICON} {config.APP_TITLE}")
+st.caption(config.APP_SUBTITLE)
+
+# ── IMAGE UPLOAD ─────────────────────────────────────────────────────────────
+new_count = render_uploader()
+if new_count > 0:
+    st.rerun()
+
+# ── 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.stop()
 
-if 'current_transcription' not in st.session_state:
-    load_current_image_data()
-if 'last_processed_audio' not in st.session_state:
-    st.session_state.last_processed_audio = None
+# ── IMAGE GALLERY ────────────────────────────────────────────────────────────
+st.divider()
+gallery_clicked = render_gallery()
+if gallery_clicked:
+    st.rerun()
+st.divider()
 
-# MAIN CONTENT 
-st.title("👁️ OphthalmoCapture")
-st.caption(f"Medical Dictation System • Model: {selected_model}")
+# Ensure a valid current image is selected
+current_id = st.session_state.current_image_id
+if current_id is None or current_id not in st.session_state.images:
+    st.session_state.current_image_id = st.session_state.image_order[0]
+    current_id = st.session_state.current_image_id
 
-col_img, col_diag = st.columns([1.5, 1])
-current_img = DATASET[st.session_state.img_index]
+current_img = sm.get_current_image()
+order = st.session_state.image_order
+current_idx = order.index(current_id)
+
+# ── Two-column layout: Image | Tools ─────────────────────────────────────────
+col_img, col_tools = st.columns([1.5, 1])
 
 with col_img:
-    st.image(current_img["url"], width="stretch")
-    
+    st.image(
+        current_img["bytes"],
+        caption=current_img["filename"],
+        use_container_width=True,
+    )
+
     # Navigation
     c1, c2, c3 = st.columns([1, 2, 1])
     with c1:
-        if st.button("⬅️ Previous"):
-            st.session_state.img_index = (st.session_state.img_index - 1) % len(DATASET)
-            load_current_image_data()
+        if st.button("⬅️ Anterior", 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()
     with c2:
-        st.markdown(f"<div style='text-align: center'><b>{current_img['label']}</b><br>(ID: {current_img['id']})</div>", unsafe_allow_html=True)
+        st.markdown(
+            f"<div style='text-align:center'><b>{current_img['filename']}</b>"
+            f"<br>({current_idx + 1} de {len(order)})</div>",
+            unsafe_allow_html=True,
+        )
     with c3:
-        if st.button("Next ➡️"):
-            st.session_state.img_index = (st.session_state.img_index + 1) % len(DATASET)
-            load_current_image_data()
+        if st.button("Siguiente ➡️", 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()
 
-with col_diag:
-    st.subheader("Dictation & Report")
-    
-    audio_wav = st.audio_input("Record Voice", key=f"audio_{current_img['id']}")
-
-    if audio_wav is not None:
-        if st.session_state.last_processed_audio != audio_wav:
-            with st.spinner("Analyzing audio..."):
-                try:
-                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
-                        tmp_file.write(audio_wav.read())
-                        tmp_path = tmp_file.name
-                    
-                    result = model.transcribe(tmp_path, language="es")
-                    new_text = result["text"].strip()
-                    
-                    if st.session_state.current_transcription:
-                        st.session_state.current_transcription += " " + new_text
-                    else:
-                        st.session_state.current_transcription = new_text
-                    
-                    st.session_state.last_processed_audio = audio_wav
-                    os.remove(tmp_path)
-                except Exception as e:
-                    st.error(f"Transcription Error: {e}")
-
-    diagnosis_text = st.text_area(
-        "Findings:", 
-        value=st.session_state.current_transcription,
-        height=300
-    )
-    
-    if diagnosis_text != st.session_state.current_transcription:
-        st.session_state.current_transcription = diagnosis_text
-
-    if st.button("💾 Save to Record", type="primary"):
-        if diagnosis_text.strip():
-            try:
-                db.save_diagnosis(current_img['id'], diagnosis_text)
-                st.success("Successfully saved to database.")
-            except Exception as e:
-                st.error(f"Save failed: {e}")
-        else:
-            st.warning("Cannot save empty diagnosis.")
+    # Delete image from session
+    if st.button("🗑️ Eliminar esta imagen", key="delete_img"):
+        sm.remove_image(current_id)
+        sm.update_activity()
+        st.rerun()
+
+with col_tools:
+    render_labeler(current_id)
+
+    st.divider()
+
+    render_recorder(current_id, model, selected_language)
+
+    st.divider()
+
+    render_downloader(current_id)

interface/services/auth_service.py

@@ -0,0 +1,99 @@
+"""OphthalmoCapture — Basic Authentication Service
+
+Provides a simple login gate using streamlit-authenticator.
+Doctors must authenticate before accessing the labeling interface.
+Their name is automatically set in the session for audit trails.
+
+If streamlit-authenticator is not installed, authentication is skipped
+and the app works in "anonymous" mode.
+"""
+
+import streamlit as st
+
+try:
+    import streamlit_authenticator as stauth
+    AUTH_AVAILABLE = True
+except ImportError:
+    AUTH_AVAILABLE = False
+
+
+# ── Default credentials ──────────────────────────────────────────────────────
+# In production, load these from a secure YAML/env.  For now, hardcoded demo.
+DEFAULT_CREDENTIALS = {
+    "usernames": {
+        "admin": {
+            "name": "Administrador",
+            "password": "$2b$12$dcvvIg0q/2hZ1pO9gBKqY./LfujFHvoJUvPDLx1qhLS0LtD2kzJoq",
+            # plain: "admin123"  — generate new hashes with stauth.Hasher
+        },
+        "doctor1": {
+            "name": "Dr. García",
+            "password": "$2b$12$dcvvIg0q/2hZ1pO9gBKqY./LfujFHvoJUvPDLx1qhLS0LtD2kzJoq",
+            # plain: "admin123"
+        },
+        "doctor2": {
+            "name": "Dra. López",
+            "password": "$2b$12$dcvvIg0q/2hZ1pO9gBKqY./LfujFHvoJUvPDLx1qhLS0LtD2kzJoq",
+            # plain: "admin123"
+        },
+    }
+}
+
+COOKIE_NAME = "ophthalmocapture_auth"
+COOKIE_KEY = "ophthalmocapture_secret_key"
+COOKIE_EXPIRY_DAYS = 1
+
+
+def _get_authenticator():
+    """Return a single shared Authenticate instance per session."""
+    if "authenticator" not in st.session_state:
+        st.session_state["authenticator"] = stauth.Authenticate(
+            credentials=DEFAULT_CREDENTIALS,
+            cookie_name=COOKIE_NAME,
+            cookie_key=COOKIE_KEY,
+            cookie_expiry_days=COOKIE_EXPIRY_DAYS,
+        )
+    return st.session_state["authenticator"]
+
+
+def require_auth() -> bool:
+    """Show login form and return True if the user is authenticated.
+
+    If streamlit-authenticator is not installed, returns True immediately
+    (anonymous mode) and sets doctor_name to empty string.
+    """
+    if not AUTH_AVAILABLE:
+        # Graceful degradation: no auth library → anonymous mode
+        return True
+
+    authenticator = _get_authenticator()
+
+    try:
+        authenticator.login(location="main")
+    except Exception:
+        pass
+
+    if st.session_state.get("authentication_status"):
+        # Set doctor name from authenticated user
+        username = st.session_state.get("username", "")
+        user_info = DEFAULT_CREDENTIALS["usernames"].get(username, {})
+        st.session_state.doctor_name = user_info.get("name", username)
+        return True
+
+    elif st.session_state.get("authentication_status") is False:
+        st.error("❌ Usuario o contraseña incorrectos.")
+        return False
+
+    else:
+        st.info("👨‍⚕️ Inicie sesión para acceder al sistema de etiquetado.")
+        return False
+
+
+def render_logout_button():
+    """Show a logout button in the sidebar (only if auth is active)."""
+    if not AUTH_AVAILABLE:
+        return
+
+    if st.session_state.get("authentication_status"):
+        authenticator = _get_authenticator()
+        authenticator.logout("🚪 Cerrar sesión", location="sidebar")

interface/services/export_service.py

@@ -0,0 +1,202 @@
+"""OphthalmoCapture — Export Service
+
+Generates in-memory ZIP packages for individual images or the full session.
+Also produces ML-ready formats (HuggingFace CSV, JSONL).
+Everything is built from st.session_state — nothing touches disk.
+"""
+
+import io
+import csv
+import json
+import zipfile
+import datetime
+import streamlit as st
+
+
+def _sanitize(name: str) -> str:
+    """Remove characters not safe for ZIP entry names."""
+    return "".join(c if c.isalnum() or c in "._- " else "_" for c in name)
+
+
+def _image_metadata(img: dict) -> dict:
+    """Build a JSON-serialisable metadata dict for one image."""
+    return {
+        "filename": img["filename"],
+        "label": img["label"],
+        "transcription": img["transcription"],
+        "transcription_original": img["transcription_original"],
+        "doctor": img.get("labeled_by", ""),
+        "timestamp": img["timestamp"].isoformat() if img.get("timestamp") else "",
+        "has_audio": img["audio_bytes"] is not None,
+    }
+
+
+# ── Individual export ────────────────────────────────────────────────────────
+
+def export_single_image(image_id: str) -> tuple[bytes, str]:
+    """Create a ZIP for one image's labeling data.
+
+    Returns (zip_bytes, suggested_filename).
+    """
+    img = st.session_state.images[image_id]
+    safe_name = _sanitize(img["filename"].rsplit(".", 1)[0])
+    folder = f"etiquetado_{safe_name}"
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        # metadata.json
+        meta = _image_metadata(img)
+        zf.writestr(f"{folder}/metadata.json", json.dumps(meta, ensure_ascii=False, indent=2))
+
+        # transcripcion.txt
+        zf.writestr(f"{folder}/transcripcion.txt", img["transcription"] or "")
+
+        # audio_dictado.wav (if recorded)
+        if img["audio_bytes"]:
+            zf.writestr(f"{folder}/audio_dictado.wav", img["audio_bytes"])
+
+    zip_bytes = buf.getvalue()
+    return zip_bytes, f"{folder}.zip"
+
+
+# ── Bulk export (full session) ───────────────────────────────────────────────
+
+def export_full_session() -> tuple[bytes, str]:
+    """Create a ZIP with all images' labeling data + a summary CSV.
+
+    Returns (zip_bytes, suggested_filename).
+    """
+    now = datetime.datetime.now().strftime("%Y-%m-%d_%H%M")
+    root = f"sesion_{now}"
+    images = st.session_state.images
+    order = st.session_state.image_order
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        # ── Summary CSV ──────────────────────────────────────────────────
+        csv_buf = io.StringIO()
+        writer = csv.writer(csv_buf)
+        writer.writerow(["filename", "label", "has_audio", "has_transcription", "doctor"])
+        for img_id in order:
+            img = images[img_id]
+            writer.writerow([
+                img["filename"],
+                img["label"] or "",
+                "yes" if img["audio_bytes"] else "no",
+                "yes" if img["transcription"] else "no",
+                img.get("labeled_by", ""),
+            ])
+        zf.writestr(f"{root}/resumen.csv", csv_buf.getvalue())
+
+        # ── Full metadata JSON ───────────────────────────────────────────
+        all_meta = []
+        for img_id in order:
+            all_meta.append(_image_metadata(images[img_id]))
+        zf.writestr(
+            f"{root}/etiquetas.json",
+            json.dumps(all_meta, ensure_ascii=False, indent=2),
+        )
+
+        # ── Per-image folders ────────────────────────────────────────────
+        for idx, img_id in enumerate(order, start=1):
+            img = images[img_id]
+            safe_name = _sanitize(img["filename"].rsplit(".", 1)[0])
+            img_folder = f"{root}/{idx:03d}_{safe_name}"
+
+            meta = _image_metadata(img)
+            zf.writestr(f"{img_folder}/metadata.json", json.dumps(meta, ensure_ascii=False, indent=2))
+            zf.writestr(f"{img_folder}/transcripcion.txt", img["transcription"] or "")
+
+            if img["audio_bytes"]:
+                zf.writestr(f"{img_folder}/audio_dictado.wav", img["audio_bytes"])
+
+    zip_bytes = buf.getvalue()
+    return zip_bytes, f"{root}.zip"
+
+
+# ── Session summary ──────────────────────────────────────────────────────────
+
+def get_session_summary() -> dict:
+    """Return a summary dict for pre-download validation."""
+    images = st.session_state.images
+    total = len(images)
+    labeled = sum(1 for img in images.values() if img["label"] is not None)
+    with_audio = sum(1 for img in images.values() if img["audio_bytes"] is not None)
+    with_text = sum(1 for img in images.values() if img["transcription"])
+    return {
+        "total": total,
+        "labeled": labeled,
+        "with_audio": with_audio,
+        "with_transcription": with_text,
+        "unlabeled": total - labeled,
+    }
+
+
+# ── ML-ready export formats (Idea F) ────────────────────────────────────────
+
+def export_huggingface_csv() -> tuple[bytes, str]:
+    """Export a CSV compatible with HuggingFace datasets.
+
+    Columns: filename, label, label_code, transcription, doctor
+    Only labeled images are included.
+
+    Returns (csv_bytes, suggested_filename).
+    """
+    import config
+
+    images = st.session_state.images
+    order = st.session_state.image_order
+    label_map = {opt["display"]: opt["code"] for opt in config.LABEL_OPTIONS}
+
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow(["filename", "label", "label_code", "transcription", "doctor"])
+
+    for img_id in order:
+        img = images[img_id]
+        if img["label"] is None:
+            continue
+        writer.writerow([
+            img["filename"],
+            img["label"],
+            label_map.get(img["label"], ""),
+            img["transcription"],
+            img.get("labeled_by", ""),
+        ])
+
+    csv_bytes = buf.getvalue().encode("utf-8")
+    now = datetime.datetime.now().strftime("%Y%m%d_%H%M")
+    return csv_bytes, f"dataset_hf_{now}.csv"
+
+
+def export_jsonl() -> tuple[bytes, str]:
+    """Export JSONL (one JSON object per line) suitable for LLM fine-tuning.
+
+    Each line: {"filename", "label", "label_code", "transcription", "doctor"}
+    Only labeled images are included.
+
+    Returns (jsonl_bytes, suggested_filename).
+    """
+    import config
+
+    images = st.session_state.images
+    order = st.session_state.image_order
+    label_map = {opt["display"]: opt["code"] for opt in config.LABEL_OPTIONS}
+
+    lines = []
+    for img_id in order:
+        img = images[img_id]
+        if img["label"] is None:
+            continue
+        obj = {
+            "filename": img["filename"],
+            "label": img["label"],
+            "label_code": label_map.get(img["label"], ""),
+            "transcription": img["transcription"],
+            "doctor": img.get("labeled_by", ""),
+        }
+        lines.append(json.dumps(obj, ensure_ascii=False))
+
+    jsonl_bytes = "\n".join(lines).encode("utf-8")
+    now = datetime.datetime.now().strftime("%Y%m%d_%H%M")
+    return jsonl_bytes, f"dataset_{now}.jsonl"

interface/services/session_manager.py

@@ -0,0 +1,157 @@
+"""
+OphthalmoCapture — Ephemeral Session Manager
+
+All image data lives exclusively in st.session_state (RAM).
+Nothing is written to disk. Data is only persisted when the user
+explicitly downloads their labeling package.
+"""
+
+import streamlit as st
+import uuid
+import datetime
+import gc
+
+
+def init_session():
+    """Initialize the ephemeral session data model."""
+    if "session_initialized" not in st.session_state:
+        st.session_state.session_initialized = True
+        st.session_state.session_id = str(uuid.uuid4())  # unique per session
+        st.session_state.images = {}            # {uuid_str: image_data_dict}
+        st.session_state.image_order = []       # [uuid_str, ...] upload order
+        st.session_state.current_image_id = None
+        st.session_state.last_activity = datetime.datetime.now()
+        st.session_state.doctor_name = ""
+        st.session_state.confirm_end_session = False
+
+
+def add_image(filename: str, image_bytes: bytes) -> str:
+    """Add an uploaded image to the in-memory session store.
+
+    Returns the generated UUID for the image.
+    """
+    img_id = str(uuid.uuid4())
+    st.session_state.images[img_id] = {
+        "filename": filename,
+        "bytes": image_bytes,
+        "label": None,                 # Set during labeling (Phase 3)
+        "audio_bytes": None,           # WAV from recording (Phase 4)
+        "transcription": "",           # Editable transcription text
+        "transcription_original": "",  # Original Whisper output (read-only)
+        "timestamp": datetime.datetime.now(),
+        "labeled_by": st.session_state.get("doctor_name", ""),
+    }
+    st.session_state.image_order.append(img_id)
+    update_activity()
+    return img_id
+
+
+def remove_image(img_id: str):
+    """Remove a single image from the session, freeing memory."""
+    if img_id in st.session_state.images:
+        # Explicitly clear heavy byte fields before deletion
+        st.session_state.images[img_id]["bytes"] = None
+        st.session_state.images[img_id]["audio_bytes"] = None
+        del st.session_state.images[img_id]
+
+    if img_id in st.session_state.image_order:
+        st.session_state.image_order.remove(img_id)
+
+    # Update current selection if the deleted image was active
+    if st.session_state.current_image_id == img_id:
+        if st.session_state.image_order:
+            st.session_state.current_image_id = st.session_state.image_order[0]
+        else:
+            st.session_state.current_image_id = None
+
+
+def get_current_image():
+    """Get the data dict for the currently selected image, or None."""
+    img_id = st.session_state.get("current_image_id")
+    if img_id and img_id in st.session_state.images:
+        return st.session_state.images[img_id]
+    return None
+
+
+def get_current_image_id():
+    """Get the UUID of the currently selected image."""
+    return st.session_state.get("current_image_id")
+
+
+def set_current_image(img_id: str):
+    """Set the currently active image by UUID."""
+    if img_id in st.session_state.images:
+        st.session_state.current_image_id = img_id
+        update_activity()
+
+
+def get_image_count() -> int:
+    """Total number of images in session."""
+    return len(st.session_state.images)
+
+
+def get_labeling_progress():
+    """Return (labeled_count, total_count)."""
+    total = len(st.session_state.images)
+    labeled = sum(
+        1 for img in st.session_state.images.values()
+        if img["label"] is not None
+    )
+    return labeled, total
+
+
+def has_undownloaded_data() -> bool:
+    """Check if there is any data in the session."""
+    return len(st.session_state.images) > 0
+
+
+def update_activity():
+    """Update the last activity timestamp."""
+    st.session_state.last_activity = datetime.datetime.now()
+
+
+def check_session_timeout(timeout_minutes: int = 30) -> bool:
+    """Return True if the session has exceeded the inactivity timeout."""
+    last = st.session_state.get("last_activity")
+    if last:
+        elapsed = (datetime.datetime.now() - last).total_seconds() / 60
+        return elapsed > timeout_minutes
+    return False
+
+
+def clear_session():
+    """Completely wipe all session data — images, audio, everything.
+
+    Called on explicit cleanup or session timeout.
+    """
+    # Explicitly null out heavy byte fields to help garbage collection
+    for img in st.session_state.get("images", {}).values():
+        img["bytes"] = None
+        img["audio_bytes"] = None
+    st.session_state.clear()
+    gc.collect()
+
+
+def get_remaining_timeout_minutes(timeout_minutes: int = 30) -> float:
+    """Return how many minutes remain before timeout, or 0 if already expired."""
+    last = st.session_state.get("last_activity")
+    if not last:
+        return 0.0
+    elapsed = (datetime.datetime.now() - last).total_seconds() / 60
+    remaining = timeout_minutes - elapsed
+    return max(0.0, remaining)
+
+
+def get_session_data_summary() -> dict:
+    """Return a summary of what data exists in the session (for warnings)."""
+    images = st.session_state.get("images", {})
+    total = len(images)
+    labeled = sum(1 for img in images.values() if img["label"] is not None)
+    with_audio = sum(1 for img in images.values() if img["audio_bytes"] is not None)
+    with_text = sum(1 for img in images.values() if img["transcription"])
+    return {
+        "total": total,
+        "labeled": labeled,
+        "with_audio": with_audio,
+        "with_transcription": with_text,
+    }

interface/services/whisper_service.py

@@ -0,0 +1,102 @@
+"""OphthalmoCapture — Whisper Transcription Service
+
+Encapsulates all Whisper-related logic: model loading, transcription,
+and segment-level timestamps.  Temporary files are ALWAYS cleaned up.
+"""
+
+import os
+import shutil
+import tempfile
+import streamlit as st
+import whisper
+
+# ── Ensure ffmpeg is available ───────────────────────────────────────────────
+# If system ffmpeg is not in PATH, use the bundled one from imageio-ffmpeg.
+if shutil.which("ffmpeg") is None:
+    try:
+        import imageio_ffmpeg
+        _ffmpeg_real = imageio_ffmpeg.get_ffmpeg_exe()
+        # The bundled binary has a long name; create an alias as ffmpeg.exe
+        # next to it so that Whisper (which calls "ffmpeg") can find it.
+        _ffmpeg_alias = os.path.join(os.path.dirname(_ffmpeg_real), "ffmpeg.exe")
+        if not os.path.exists(_ffmpeg_alias):
+            try:
+                os.link(_ffmpeg_real, _ffmpeg_alias)   # hard link (no admin)
+            except OSError:
+                import shutil as _sh
+                _sh.copy2(_ffmpeg_real, _ffmpeg_alias)  # fallback: copy
+        os.environ["PATH"] = (
+            os.path.dirname(_ffmpeg_alias) + os.pathsep + os.environ.get("PATH", "")
+        )
+    except ImportError:
+        pass  # Will fail later with a clear Whisper error
+
+
+@st.cache_resource
+def load_whisper_model(model_size: str):
+    """Load and cache a Whisper model."""
+    print(f"Loading Whisper model: {model_size}...")
+    return whisper.load_model(model_size)
+
+
+def transcribe_audio(model, audio_bytes: bytes, language: str = "es") -> str:
+    """Transcribe raw WAV bytes and return plain text.
+
+    The temporary file is **always** deleted (try/finally).
+    """
+    tmp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+            tmp.write(audio_bytes)
+            tmp_path = tmp.name
+
+        result = model.transcribe(tmp_path, language=language)
+        return result.get("text", "").strip()
+    except Exception as e:
+        st.error(f"Error de transcripción: {e}")
+        return ""
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def transcribe_audio_with_timestamps(
+    model, audio_bytes: bytes, language: str = "es"
+) -> tuple[str, list[dict]]:
+    """Transcribe raw WAV bytes and return (plain_text, segments).
+
+    Each segment dict contains:
+        {"start": float, "end": float, "text": str}
+
+    Useful for syncing transcript highlights with audio playback.
+    """
+    tmp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+            tmp.write(audio_bytes)
+            tmp_path = tmp.name
+
+        result = model.transcribe(tmp_path, language=language)
+        text = result.get("text", "").strip()
+
+        segments = []
+        for seg in result.get("segments", []):
+            segments.append({
+                "start": round(seg["start"], 2),
+                "end": round(seg["end"], 2),
+                "text": seg["text"].strip(),
+            })
+
+        return text, segments
+    except Exception as e:
+        st.error(f"Error de transcripción: {e}")
+        return "", []
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def format_timestamp(seconds: float) -> str:
+    """Convert seconds to MM:SS format."""
+    m, s = divmod(int(seconds), 60)
+    return f"{m:02d}:{s:02d}"

interface/utils.py

@@ -1,67 +1,31 @@
-import streamlit as st
-import whisper
+"""OphthalmoCapture — Utility Functions."""
+
 import os
-import pandas as pd
 
 
-@st.cache_resource
-def load_whisper_model(model_size):
-    """Loads the Whisper model (Cached)."""
-    print(f"Loading Whisper model: {model_size}...")
-    return whisper.load_model(model_size)
+# Known image magic byte signatures
+_IMAGE_SIGNATURES = [
+    (b"\xff\xd8\xff",          "JPEG"),
+    (b"\x89PNG\r\n\x1a\n",    "PNG"),
+    (b"II\x2a\x00",           "TIFF (LE)"),
+    (b"MM\x00\x2a",           "TIFF (BE)"),
+]
+
 
 def setup_env():
-    """Sets up environment variables."""
+    """Set up environment variables."""
     os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
 
-def load_dataset(csv_path, image_folder):
-    """
-    Reads a CSV and checks for image existence.
-    Expected CSV columns: 'filename' (required), 'label' (optional).
-    """
-    images_list = []
-    
-    # 1. Check if CSV exists
-    if not os.path.exists(csv_path):
-        st.error(f"⚠️ CSV file not found: {csv_path}")
-        return []
-
-    try:
-        df = pd.read_csv(csv_path)
-    except Exception as e:
-        st.error(f"Error reading CSV: {e}")
-        return []
 
-    # 2. Iterate through CSV
-    # We look for a 'filename' column. If not found, use the first column.
-    filename_col = 'filename'
-    if 'filename' not in df.columns:
-        filename_col = df.columns[0]
-        st.warning(f"Column 'filename' not found. Using '{filename_col}' as filename.")
+def validate_image_bytes(data: bytes) -> bool:
+    """Verify that *data* starts with a known image magic-byte header.
 
-    for index, row in df.iterrows():
-        base_name = str(row[filename_col]).strip()
-        
-        # Construct full path
-        full_path = os.path.join(image_folder, base_name)
-        
-        # Handle extensions if filename doesn't have them (optional check)
-        if not os.path.exists(full_path):
-            # Try adding common extensions if file not found
-            for ext in ['.jpg', '.png', '.jpeg', '.tif']:
-                if os.path.exists(full_path + ext):
-                    full_path = full_path + ext
-                    break
-        
-        # Only add if file actually exists
-        if os.path.exists(full_path):
-            images_list.append({
-                "id": base_name,
-                "label": row.get('label', base_name), # Use 'label' column or fallback to name
-                "url": full_path # Streamlit accepts local paths here
-            })
-    
-    if not images_list:
-        st.warning(f"No valid images found in '{image_folder}' matching the CSV.")
-        
-    return images_list
+    Returns True if valid, False otherwise.  This prevents non-image files
+    from being accepted even if they have a valid extension.
+    """
+    if not data or len(data) < 8:
+        return False
+    for sig, _ in _IMAGE_SIGNATURES:
+        if data[: len(sig)] == sig:
+            return True
+    return False

requirements.txt

@@ -1,5 +1,6 @@
 streamlit
 openai-whisper
+imageio-ffmpeg
 torch
 pandas
 firebase-admin
@@ -7,4 +8,5 @@ notebook
 transformers 
 pillow
 whisper
-numba
+numba
+streamlit-authenticator