Upload 6 files

databases.py

@@ -1,13 +1,18 @@
 import os
 import sqlite3
 from contextlib import contextmanager
-from typing import Optional, Dict, Any, List, Tuple
 from datetime import datetime
+from pathlib import Path
+from statistics import median
+from typing import Optional, Dict, Any, List, Tuple
 
 # Reutilizamos la misma lógica que antes, pero centralizada en este módulo
 
 DEFAULT_DB_PATH = None  # set by set_db_path at runtime
 
+# Ruta a la base de dades de feedback agregat (separa de login.db)
+FEEDBACK_DB_PATH = Path(__file__).resolve().parent / "data" / "feedback.db"
+
 
 def set_db_path(db_path: str):
     global DEFAULT_DB_PATH
@@ -134,6 +139,145 @@ def get_feedback_ad_for_video(video_name: str):
         return cur.fetchall()
 
 
+def _connect_feedback_db() -> sqlite3.Connection:
+    """Connexió directa a demo/data/feedback.db.
+
+    És independent de DEFAULT_DB_PATH perquè aquesta BD és específica de feedback
+    agregat importat des de engine.
+    """
+
+    FEEDBACK_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(FEEDBACK_DB_PATH))
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def get_feedback_video_stats(agg: str = "mitjana") -> List[Dict[str, Any]]:
+    """Retorna estadístiques agregades per vídeo de demo/data/feedback.db.
+
+    agg pot ser:
+    - "mitjana": mitjana dels scores per vídeo.
+    - "mediana": mediana dels scores per vídeo.
+    - "inicial": primer registre (per timestamp) per vídeo.
+    - "actual": darrer registre (per timestamp) per vídeo.
+    """
+
+    agg = (agg or "mitjana").lower()
+    with _connect_feedback_db() as conn:
+        cur = conn.execute(
+            """
+            SELECT
+              video_name,
+              timestamp,
+              score_1,
+              score_2,
+              score_3,
+              score_4,
+              score_5,
+              score_6
+            FROM feedback
+            """
+        )
+        rows = cur.fetchall()
+
+    by_video: Dict[str, List[sqlite3.Row]] = {}
+    for row in rows:
+        vn = row["video_name"]
+        by_video.setdefault(vn, []).append(row)
+
+    def parse_ts(ts: str) -> datetime:
+        # Format des d'init_feedback.py: "YYYY-MM-DD HH:MM:SS"
+        try:
+            return datetime.strptime(ts, "%Y-%m-%d %H:%M:%S")
+        except Exception:
+            return datetime.min
+
+    result: List[Dict[str, Any]] = []
+    for video_name, vrows in by_video.items():
+        if not vrows:
+            continue
+
+        # Ordenem per timestamp per als modes "inicial" i "actual"
+        vrows_sorted = sorted(vrows, key=lambda r: parse_ts(r["timestamp"]))
+
+        def agg_values(key: str) -> Optional[float]:
+            vals = [r[key] for r in vrows if r[key] is not None]
+            if not vals:
+                return None
+            if agg == "mitjana":
+                return float(sum(vals) / len(vals))
+            if agg == "mediana":
+                return float(median(vals))
+            if agg == "inicial":
+                return float(vrows_sorted[0][key]) if vrows_sorted[0][key] is not None else None
+            if agg == "actual":
+                return float(vrows_sorted[-1][key]) if vrows_sorted[-1][key] is not None else None
+            # fallback a mitjana si el mode no és reconegut
+            return float(sum(vals) / len(vals))
+
+        row_out: Dict[str, Any] = {
+            "video_name": video_name,
+            "n": len(vrows),
+        }
+        for i in range(1, 7):
+            key = f"score_{i}"
+            row_out[key] = agg_values(key)
+
+        result.append(row_out)
+
+    # Ordenació per defecte alfabètica pel nom; l'ordre final es decidirà a la UI
+    result.sort(key=lambda r: r["video_name"])
+    return result
+
+
+def get_feedback_score_labels() -> List[str]:
+    """Extreu els noms dels sis ítems a partir del camp `scores` d'un registre.
+
+    El camp `scores` conté el contingut d'`eval.csv`. El format esperat és:
+    - Primera línia: capçalera.
+    - Línies següents: fins a 6 files amb "nom_item,valor,justificació".
+
+    Retorna una llista de 6 etiquetes (strings). Si no es pot determinar, torna
+    ['score_1', ..., 'score_6'].
+    """
+
+    default_labels = [f"score_{i}" for i in range(1, 7)]
+
+    with _connect_feedback_db() as conn:
+        cur = conn.execute(
+            "SELECT scores FROM feedback WHERE scores IS NOT NULL AND scores != '' LIMIT 1"
+        )
+        row = cur.fetchone()
+
+    if row is None:
+        return default_labels
+
+    raw = row["scores"]
+    if not raw:
+        return default_labels
+
+    lines = [line.strip() for line in raw.splitlines() if line.strip()]
+    if len(lines) <= 1:
+        return default_labels
+
+    data_lines = lines[1:]
+    labels: List[str] = []
+    for line in data_lines:
+        if len(labels) >= 6:
+            break
+        parts = line.split(",", 2)
+        if not parts:
+            continue
+        label = parts[0].strip().strip('"')
+        labels.append(label or default_labels[len(labels)])
+
+    # Assegurar que sempre hi ha 6 etiquetes
+    while len(labels) < 6:
+        labels.append(default_labels[len(labels)])
+
+    return labels[:6]
+
+
 def get_feedback_ad_stats():
     # medias por vídeo y ranking
     with get_conn() as conn:

page_modules/analyze_transcriptions.py

@@ -332,7 +332,7 @@ def render_analyze_transcriptions_page(api, permissions: Dict[str, bool]) -> Non
     else:
         if st.button("Enviar valoració", type="primary", use_container_width=True):
             try:
-                from database import add_feedback_ad
+                from databases import add_feedback_ad
                 
                 # Guardar en la base de datos
                 add_feedback_ad(
@@ -347,8 +347,8 @@ def render_analyze_transcriptions_page(api, permissions: Dict[str, bool]) -> Non
                     comments=comments or None,
                 )
                 
-                # También guardar en CSV
-                video_dir = Path("demo/videos") / seleccio
+                # También guardar en CSV (reubicado en demo/data/videos)
+                video_dir = Path("demo/data/videos") / seleccio
                 version = st.session_state.get("selected_version", "MoE")
                 csv_path = video_dir / version / "eval.csv"
                 

page_modules/statistics.py

@@ -5,41 +5,78 @@ from __future__ import annotations
 import pandas as pd
 import streamlit as st
 
-from database import get_feedback_ad_stats
+from databases import get_feedback_video_stats
 
 
 def render_statistics_page() -> None:
     st.header("Estadístiques")
 
-    stats = get_feedback_ad_stats()
+    st.markdown(
+        """
+        Aquest panell mostra **estadístiques agregades per vídeo** a partir de la taula
+        `feedback` de `demo/data/feedback.db`. Per a cada vídeo es calcula, segons el
+        mode triat, una puntuació per a cadascun dels `score_1` ... `score_6`.
+        """
+    )
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        mode_label = st.selectbox(
+            "Mode d'agregació",
+            ["mitjana", "mediana", "inicial", "actual"],
+            help=(
+                "mitjana: mitjana de totes les valoracions; "
+                "mediana: valor central; "
+                "inicial: primer registre en el temps; "
+                "actual: darrer registre en el temps."
+            ),
+        )
+
+    order_options = {
+        "nom": "video_name",
+        "score_1": "score_1",
+        "score_2": "score_2",
+        "score_3": "score_3",
+        "score_4": "score_4",
+        "score_5": "score_5",
+        "score_6": "score_6",
+    }
+
+    with col2:
+        order_label = st.selectbox(
+            "Ordenar per",
+            list(order_options.keys()),
+            help=(
+                "Indica el camp pel qual s'ordenen els vídeos a la taula: "
+                "nom del vídeo o algun dels score_1 .. score_6."
+            ),
+        )
+
+    stats = get_feedback_video_stats(agg=mode_label)
     if not stats:
-        st.caption("Encara no hi ha valoracions.")
+        st.caption("Encara no hi ha valoracions a demo/data/feedback.db.")
         st.stop()
 
-    df = pd.DataFrame(stats, columns=stats[0].keys())
-    ordre = st.radio(
-        "Ordre de rànquing",
-        ["Descendent (millors primer)", "Ascendent (pitjors primer)"],
-        horizontal=True,
-    )
-    if ordre.startswith("Asc"):
-        df = df.sort_values("avg_global", ascending=True)
-    else:
-        df = df.sort_values("avg_global", ascending=False)
+    df = pd.DataFrame(stats)
+
+    # Ordenació segons el selector
+    order_key = order_options[order_label]
+    ascending = order_key in {"video_name", "nom"}
+    df = df.sort_values(order_key, ascending=ascending, na_position="last")
 
-    st.subheader("Rànquing de vídeos")
+    st.subheader("Taula agregada per vídeo")
     st.dataframe(
         df[
             [
                 "video_name",
                 "n",
-                "avg_global",
-                "avg_transcripcio",
-                "avg_identificacio",
-                "avg_localitzacions",
-                "avg_activitats",
-                "avg_narracions",
-                "avg_expressivitat",
+                "score_1",
+                "score_2",
+                "score_3",
+                "score_4",
+                "score_5",
+                "score_6",
             ]
         ],
         use_container_width=True,